零基础学Python，本文是我个人的随心笔记，希望对你有益！
注释：单行：#…… 多行：单引号（’’’） 双引号（”””）
基本数据类型：整数：int；浮点数：float（只有这两种）；str：字符串；bool：布尔类型；complete：复数；list:列表；tuple:元组；set:集合；dict:字典
1 >>> type(2) 2 <class 'int'> 3 >>> type(1.1) 4 <class 'float'> 5 >>> type(1+1.1) 6 <class 'float'> 7 >>> type(2/2) 8 <class 'float'> 9 >>> type(2//2) 10 <class 'float'> 11 >>> 2//2 12 1 13 >>> 2/2 14 1.0 15 >>> 2*2 16 4
type()用来获取该表达式的数据类型
//: 除并取整
/ ：除之后商有一位小数
1 print("I", end=" ") 2 print("love ", end='') 3 print("you !") # I love you !（没有换行）
进制转换
1 >>> 0b10 # 二进制 2 2 3 >>> 0o10 # 八进制 4 8 5 >>> 0x10 # 十六进制 6 16 7 >>> bin(0o10) # 八进制 转换 二进制 8 '0b1000' 9 >>> bin(10) # 十进制 转换 二进制 10 '0b1010' 11 >>> bin(0x10) # 十六进制 转换 二进制 12 '0b10000' 13 >>> int(0b10) # 二进制 转换 八进制 14 2 15 >>> int(0o10) # 十进制 转换 八进制 16 8 17 >>> int(0x10) # 十六进制 转换 八进制 18 16 19 >>> hex(0b10) # 二进制 转换 十六进制 20 '0x2' 21 >>> hex(0o10) # 八进制 转换 十六进制 22 '0x8' 23 >>> hex(10) # 十进制 转换 十六进制 24 '0xa'
布尔类型
1 # True和False首字母都要大写 2 >>> type(True) 3 <class 'bool'> 4 >>> type(False) 5 <class 'bool'> 6 >>> int(True) 7 1 8 >>> int(False) 9 0 10 >>> bool(1) 11 True 12 >>> bool(0) 13 False 14 >>> bool(2) 15 True 16 >>> bool(2.2) 17 True 18 >>> bool(-2) 19 True 20 >>> bool('abc') 21 True 22 >>> bool('') 23 False 24 >>> bool([1,2,3]) 25 True 26 >>> bool([]) 27 False 28 >>> bool({1,2,3}) 29 True 30 >>> bool({}) 31 False 32 >>> bool(None) 33 False 34 >>> 36j # 输出复数 35 36j
str(不可变)：字符串 -> 单引号，双引号，三引号（成对出现）
1 >>> "let's go !" 2 "let's go !" 3 >>> ''' 4 ... 1 5 ... 2 6 ... a 7 ... b 8 ... ''' 9 '\n1\n2\na\nb\n' 10 >>> "let's go !" 11 "let's go !" 12 >>> ''' 13 ... 1 14 ... 2 15 ... a 16 ... b 17 ... ''' 18 '\n1\n2\n3\na\nb\n' 19 >>> """\n1\n2\na\nb\n""" 20 '\n1\n2\na\nb\n' 21 >>> print("""\n1\n2\n3\na\nb\n""") 22 23 1 24 2 25 3 26 a 27 b 28 29 结束
format格式化函数
1 >>> "{} {}".format("hello","world") # 不设置指定位置，按默认顺序 2 'hello world' 3 >>> "{0} {1}".format("hello","world") # 设置指定位置 4 'hello world' 5 >>> "{1} {0} {1}".format("hello","world") # 设置指定位置 6 'world hello world' 7 >>> "网站名：{name}，地址：{url}".format(name="世界与你同在",url=" http://www.worldiwiu.ltd/main ") # 设置参数 8 '网站名：世界与你同在，地址：http://www.worldiwiu.ltd/main ' 9 >>> site = {"name": "世界与你同在", "url": " http://www.worldiwiu.ltd/main "} # 通过字典设置参数 10 >>> "网站名：{name}，地址：{url}".format(**site) # 通过**可讲字典中的值分配给关键字参数 11 '网站名：世界与你同在，地址：http://www.worldiwiu.ltd/main ' 12 >>> list = ['世界与你同在',' http://www.worldiwiu.ltd/main '] 13 >>> "网站名：{0[0]}，地址：{0[1]}".format(list) # 通过列表索引设置参数；“0”是必须的 14 '网站名：世界与你同在，地址：http://www.worldiwiu.ltd/main '
关键字参数和默认值
像这样使用名称指定的参数称为关键字参数，只要有点是有足浴澄清各个参数的作用
>>>store(patient=’Mr.Brainsample’,hour=10,minute=20,day=13,month=5)
虽然这样做的输入量多些，但每个参数的作用清晰明了。另外，参数的顺序错了也没有关系，关键字参数最大的有点在于，可以指定默认值
1 def hello_1(getting,name): 2 print(‘{},{}!’.format(getting, name)) 3 >>>hello_1(name=’world’, getting=’Hello’) 4 Hello,world! 5 6 def hello_1(name,getting): 7 print(‘{},{}!’.format(name, getting)) 8 >>>hello_2(getting=’Hello’, name=’world’) 9 world,Hello! 10 11 def hello_3(getting=‘Hello’,name=‘world’): 12 print(‘{},{}!’.format(getting, name)) 13 # 参数设置默认值 14 >>>hello_3() 15 Hello,world! 16 >>>hello_3('I love', 'you ') 17 I love,you ! 18 >>>hello_3(name='xing') 19 Hello,xing! 20 21 def hello_4(name, getting='Hello', fuhao='!'): 22 print('{},{}{}'.format(getting, name, fuhao)) 23 >>>hello_4('xing') 24 Hello,xing! 25 >>>hello_4('兴,今天过得好吗', getting='你好', fuhao='?') 26 你好,兴,今天过得好吗?
收集参数
1 def print_params(*params): 2 print(params) 3 >>> print_params('Testing') 4 ('Testing',) 5 >>> print_params(1,2,3) 6 (1, 2, 3) 7 8 def print_params_2(title, *params): 9 print(title, end="") 10 print(params) 11 >>>print_params_2('Params:', 1, 2, 3) 12 Params:(1, 2,3)# *:收集余下的位置参数 13 14 def print_params_3(x, *y, z): 15 print(x, y, z) 16 >>>print_params_3(1, 2, 3, z=4) 17 1 (2, 3) 4 18 print_params_3(1, 2, 3, 4) 19 # 星号不会收集关键字参数 20 TypeError: print_params_3() missing 1 required keyword-only argument: 'z' 21 22 # 要收集关键字参数,可使用两个星号 23 def print_params_4(**params): 24 print(params) 25 >>>print_params_4(x=1, y=2, z=3) 26 {'x': 1, 'y': 2, 'z': 3} 27 28 def print_params_5(x, y, a, z=4, *pospar, **keypar): 29 print(x, y, z, a) 30 print(pospar) 31 print(keypar) 32 print_params_5(1, 2, 0, 3, 4, 5, 7, 6, foo=9, bar=8) 33 1 2 3 0 34 (5, 7, 6) 35 {'foo': 9, 'bar': 8}
分配参数
1 def add(x, y): 2 return x + y 3 b=(2, 5) 4 print(add(*b)) # 显示: 7 5 # 这与前面的操作差不多是相反:不是收集参数,而是分配参数。这是通过在调用函数(而不是定义函数)时使用运算符*实现的 6 params = {'name': '兴', 'getting': '你好'} 7 hello_3(**params) # 你好,兴!
转义字符
| 转义字符 |
描述 |
| \(在行尾时) |
续行符 |
| \\ |
反斜杠符号 |
| \' |
单引号 |
| \" |
双引号 |
| \a |
响铃 |
| \b |
退格(Backspace) |
| \e |
转义 |
| \000 |
空 |
| \n |
换行 |
| \v |
纵向制表符 |
| \t |
横向制表符 |
| \r |
回车 |
| \f |
换页 |
| \oyy |
八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy |
十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other |
其它的字符以普通格式输出 |
1 >>> print(r'I\nlove\nyou') # 加r之后，将输出原始字符串 2 I\nlove\nyou 3 >>> print('I\nlove\nyou') 4 I 5 love 6 you
字符切片
1 >>> "hello word"[-0] 2 'h' 3 >>> "hello word"[0] 4 'h' 5 >>> "hello word"[2:5] 6 'llo' 7 >>> "hello word"[2:-1] 8 'llo wor' 9 >>> "I love you"[1] 10 ' ' # 空格也将会输出 11 >>> "I love you"[2:] 12 'love you' 13 >>> "I love you"[-3:] 14 'you' 15 >>> "I love you"[:-1] 16 'I love yo' 17 >>> "I love you"[:-0] 18 '' 19 >>> "I love you"[:0] 20 '' 21 >>> ["I","love","you"][1:] 22 ['love', 'you'] 23 >>> ["I","love","you"][1:2]*3 24 ['love', 'love', 'love'] 25 >>> type(["I","love","you"]) 26 <class 'list'> 27 >>> (("I","love","you"))[1:] 28 ('love', 'you') 29 >>> "I love yuo I love you I love you"[2:15:3] 30 'leuIo' 31 >>> "I love yuo I love you I love you"[2::3] 32 'leuIo u vy' 33 # 2 :表示索引1； 15:表示索引2； 3 ：表示每隔三个输出一个字符 34 >>> "love" in ["I","love","yuo"] 35 True 36 # 表达式1 in 表达式 => 表达式1是否在表达式2中
元组：( ) 列表：[ ] 字典：{ }（无序的，没有索引，不可切片）
1 >>> type(set()) # 定义空的集合 2 <class 'set'> 3 >>> {1,2,3,4,5,6,7} - {3,4} # 差集 4 {1, 2, 5, 6, 7} 5 >>> {1,2,3,4,5,6,7} & {3,4} # 交集 6 {3, 4} 7 >>> {1,2,3,4,5,6,7} | {3,4} # 并集 8 {1, 2, 3, 4, 5, 6, 7}
位运算符
| & -> 与 |
| -> 或 |
^ -> 异或 |
- -> 取反 |
<< -> 左移动 |
>> -> 右移动 |
int str tuple （不可变）值类型 list set dict（可变）引用类型
成员资格运算符 in not in 测试该变量是否在该元组（列表、集合）中
相同运算符 is not is 比较变量是否是同一个对象
list：列表
| list01 = [1,2,3] list01.append(4) print("list01:", list01) list02 = list01 list03 = list01.copy() print("list02:", list02) list02[1] = 0 print("list03:", list03) print("list02:", list02) print("list01:", list01) list01.clear() list01[2:2] = [8] print("list03:", list03) print("list02:", list02) print("list01:", list01) |
list01: [1, 2, 3, 4]
list02: [1, 2, 3, 4]
list03: [1, 2, 3, 4] list02: [1, 0, 3, 4] list01: [1, 0, 3, 4] []
list03: [1, 2, 3, 4] list02: [1, 0, 8, 3, 4] list01: [1, 0, 8, 3, 4] |
append:用于将一个对象附加到列表末尾
=:这种复制（同一对象） copy：复制列表（两个不同对象）
clear：清空该列表 在列表中插入一个元素 |
列表函数
| len() |
返回列表的长度 |
| max() |
返回列表中最大值 |
| min() |
返回列表中最小值 |
| list() |
用于将元组转化为列表 |
列表方法
| append(object) |
用于将一个对象附加到列表末尾 |
1 >>> list01 = [1, 2, 3] 2 >>> list.append(4) 3 >>> list01.append(4) 4 >>> list01 5 [1, 2, 3, 4] |
| clear() |
清空列表的内容 |
1 >>> list01 = [1, 2, 3] 2 >>> list01.clear() 3 >>> list01 4 [] |
| copy() |
复制列表（复制成两个不同对象） |
1 >>> list01 = [1, 2, 3, 4] 2 >>> list02 = list01.copy() 3 >>> list02 4 [1, 2, 3, 4] |
| count(value) |
计算指定的元素在列表中出现了多少次 |
1 >>> list01 = [1, 2, 3, 4, 1, 2, [3, 4], [1, 2, [3, 4]]] 2 >>> list01.count(3) 3 1 4 >>> list01.count([3, 4]) 5 1 |
| extend(list) |
能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提供给方法extend |
1 >>> list01 = [1, 2, 3, 4] 2 >>> list02 = [5, 6, 7, 8] 3 >>> list01 + list02 4 [1, 2, 3, 4, 5, 6, 7, 8] 5 >>> list01 6 [1, 2, 3, 4] 7 >>> list01.extend(list02) 8 >>> list01 9 [1, 2, 3, 4, 5, 6, 7, 8] |
| index(value) |
在列表中查找指定值第一次出现的索引 |
1 >>> list01 = ["1", "2", "3", "4"] 2 >>> list01.index('3') 3 2 |
| insert(index,object) |
用于将一个对象插入列表 |
1 >>> list01 = [1, 2, 4, 5] 2 >>> list01.insert(2,"three") 3 >>> list01 4 [1, 2, 'three', 4, 5] |
| pop([index]) |
从列表中删除一个元素（末尾为最后一个元素），并返回该元素 （pop是唯一既修改列表有返回一个非None值的列表方法；使用pop可实现一种常见的数据结构——栈（stack），后进先出（LIFO）） |
1 >>> list01 = [1, 2, 3, 4] 2 >>> list01.pop() 3 4 4 >>> list01 5 [1, 2, 3] 6 >>> list01.pop(0) 7 1 8 >>> list01 9 [2, 3] |
| remove(value) |
用于删除第一个为指定值的元素 |
1 >>> list01 = [1, 2, 3, 4, 2, 4, 3, 1] 2 >>> list01.remove(1) 3 >>> list01 4 [2, 3, 4, 2, 4, 3, 1] |
| reverse() |
按相反的顺序排列列表中的元素（把列表元素反过来） |
1 >>> list01 = [1, 2, 3, 4] 2 >>> list01.reverse() 3 >>> list01 4 [4, 3, 2, 1] |
| sort() |
对列表进行升序排序 |
|
| sorted() |
对列表进行升序排序，或对字符串也可以进行排序操作 |
1 list_x = [2, 5, 6, 4, 3, 1, 8] 2 list_y = list_x.copy() 3 print("list_y:", list_y) # list_y: [2, 5, 6, 4, 3, 1, 8] 4 list_y.sort() 5 print("list_y:", list_y) # list_y: [1, 2, 3, 4, 5, 6, 8] 6 print("list_y:", list_y.sort()) # list_y: None(不能直接点sort()方法) 7 list_z = sorted(list_x) 8 print("list_z:", list_z) # list_z: [1, 2, 3, 4, 5, 6, 8] 9 print(sorted('Python')) # ['P', 'h', 'n', 'o', 't', 'y'] 10 list_x = ['2', '5', '6', '4', '3', '1', '8'] 11 list_y.sort(key=len, reverse=True) 12 print("list_y:", list_y) # list_y: ['1', '2', '3', '4', '5', '6', '8'] 13 list_y.sort(key=len) 14 print("list_y:", list_y) # list_y: ['1', '2', '3', '4', '5', '6', '8'] 15 list_y.sort(reverse=True) 16 print("list_y:", list_y) # list_y: ['8', '6', '5', '4', '3', '2', '1'] |
tuple:元组（不可变）
元组函数
| len() |
返回元组长度 |
| max() |
返回元组最大值 |
| min() |
返回元组最小值 |
| tuple() |
用于将列表转换为元组 |
| sum() |
求元组中所有元素之和 |
dict:字典（无序）
格式：{key1 : value1, key2 : value2}
key：不可变的类型
1 >>> {'Q':'新月打击','W':'苍白之瀑','E':'月之降临','R':'月神冲刺'}['Q'] 2 '新月打击'
字典函数
| len(dict) |
计算字典元素个数 |
| str(dict) |
输出字典以可打印的字符串表示 |
| type(variable) |
返回输入的变量类型 |
字典方法
>>> dict = {} # 新建空字典
| clear() |
用于清除字典中的所有元素 |
|||
| copy() |
用于复制字典 |
|||
| get(key,[,d]) |
该方法中key是字典的键值，d是键值的默认值。若存在key就返回其值，否则返回d |
1 >>> dict.get("D","闪现") 2 '闪现' 3 >>> dict 4 {'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'} |
||
| items() |
该方法使用字典中元素创建一个以(key,value)为一组的元组对象 |
1 >>> dict.items() 2 dict_items([('Q', '新月打击'), ('W', '苍白之瀑'), ('E', '月之降临'), ('R', '月神冲刺')]) |
||
| keys() |
该方法使用字典中的键值来创建一个列表对象 |
1 >>> dict.keys() 2 dict_keys(['Q', 'W', 'E', 'R']) |
||
| values |
该方法使用字典中键值来创建一个列表对象 |
1 >>> dict.values() 2 dict_values(['新月打击', '苍白之瀑', '月之降临', '月神冲刺']) |
||
| popitem() |
该方法用于删除字典中的随机一个元素 |
1 >>> dict.popitem() 2 ('R', '月神冲刺') 3 >>> dict 4 {'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临'} |
||
| setdefault(key[,d]) |
该方法中key是字典的键值，d是键值的默认值。若key存在，就返回其值，否则返回d |
1 >>> dict.setdefault("D","闪现") 2 '闪现' 3 >>> dict 4 {'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺', 'D': '闪现'} |
||
| update(E) |
该方法中E是字典对象，由字典对象E来更新此字典 |
1 >>> print(dict.update({"D":"闪现"})) 2 {'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺', 'D': '闪现'} |
||
| fromkeys() |
创建一个新字典，其中包括指定的键，且没个键对应的值都是None |
1 >>> {}.fromkeys(['Q','W','E','R']) 2 {'Q': None, 'W': None, 'E': None, 'R': None} |
||
| values() |
返回一个由字典中的值组成的字典视图 |
1 >>> d = {} 2 >>> d[1] = 1 3 >>> d[2] = 2 4 >>> d[3] = 3 5 >>> d.values() 6 dict_values([1, 2, 3]) |
先定义一个空字典
向字典中添加元素
输出字典视图 打印字典视图 |
|
迭代器与生成器
迭代是Python最强大的功能之一，是访问集合元素的一种方式
迭代器是一个可以记住遍历的位置的对象
迭代器对象从集合的第一元素开始访问，直到所有哦的元素被访问完结束。迭代器只能往前不会后退
迭代器有两个基本的方法：iter()和next()
StopItertion异常用于标识迭代的完成，防止出现无限 循环的情况，在__next__()方法中我们可以设置在完成指定循环次数后接触发StopItertion异常来结束迭代。
生成器：
在Python中，使用了yield的函数被称为生成器（generator）
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能永不迭代操作，更简单点理解生成器就是一个迭代器
在调用生成器运行的过程中，每次遇到yield时函数会暂停并保存当亲所有的运行信息，返回yield的值，并在下一次执行next()方法是从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
运算符的优先级
| 运算符说明 |
Python运算符 |
优先级 |
| 索引运算符 |
x[index]或x[index:index2[:index3]] |
18、19 |
| 属性访问 |
x.attrbute |
17 |
| 乘方 |
** |
16 |
| 按位取反 |
~ |
15 |
| 符号运算符 |
+或- |
14 |
| 乘、除 |
*、/、//、% |
13 |
| 加、减 |
+、- |
12 |
| 位移 |
>>、<< |
11 |
| 按位与 |
& |
10 |
| 按位异或 |
^ |
9 |
| 按位或 |
| |
8 |
| 比较运算符 |
==、!=、>、>=、<、<= |
7 |
| is运算符 |
is、is not |
6 |
| in运算符 |
in、not in |
5 |
| 逻辑非 |
not |
4 |
| 逻辑与 |
and |
3 |
| 逻辑或 |
or |
2 |
字符串
1 >>> a = "你好, %s, 你的房间号是%d。" 2 >>> b = ('张先生',102) 3 >>> a % b 4 '你好, 张先生, 你的房间号是102。'
| %% |
百分号标记 |
| %c |
字符及其ASCII码 |
| %s |
字符串 |
| %d |
有符号整数（十进制） |
| %u |
无符号整数（十进制） |
| %o |
无符号整数（八进制） |
| %x |
无符号整数（十六进制） |
| %X |
无符号整数（十六进制大写字符） |
| %e |
浮点数字（科学计数法 ） |
| %E |
浮点数字（科学计数法，用E代替e） |
| %f |
浮点数字（用小数点符号） |
| %g |
浮点数字（根据值的大小采用%e或%f） |
| %G |
浮点数字（类似于%g） |
| %p |
指针（用于十六进制打印值的内存地址） |
| %n |
存储输出字符的数量放进参数列表下一个变量中 |
符号
| 符号 |
说明 |
| m.n |
m是显示的最小总宽度，n是小数点后的位数 |
| - |
用于左对齐 |
| + |
在正数前面显示加号（+） |
| # |
在八进制数面前显示‘0o’，在十六进制数前面显示'0x‘或者’0X' |
| 0 |
显示的数字前面填充‘0’取代空格 |
字符串方法、使用说明和案例
| 字符串方法 |
使用说明 |
案例 |
| capitalize() |
用于将字符串的第一个字母变成大写，其他字母变成小写 |
1 >>> str = "i Love you" 2 >>> str.capitalize() 3 'I love you' |
| count(String,start,end) |
用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置 |
1 >>> s = 'o' 2 >>> str.count(s) 3 2 4 >>> str.count(s,0,5) 5 0 6 >>> str.count(s,0,12) 7 1 |
| find(String,start,end) |
用于检测字符串中是否含子字符串。若含有子字符串，则返回开始的索引值；，否则返回 -1 还可以指定位置去查找子串 |
1 >>> str = "Python程序设计案例教程" 2 >>> s = "程序" 3 >>> str.find(s, 0, len(str)) 4 6 |
| index(String,start,end) |
用于检测字符串中是否含子字符串。若含有，则返回开始索引值；否则会报一个异常 |
1 >>> str = "Python程序设计案例教程" 2 >>> s = "程序" 3 >>> str.index(s, 0, len(str)) 4 6 5 >>> str.index(s, 7, len(str)) 6 Traceback (most recent call last): 7 File "<stdin>", line 1, in <module> 8 ValueError: substring not found |
| isalnum() |
用于检测字符串是否由汉字、字母和数字组成 |
1 >>> str = "Python程序设计案例教程" 2 >>> str.isalnum() 3 True 4 >>> str = "Python 程序设计案例教程" 5 >>> str.isalnum() 6 False # 该字符串有空格 |
| join(sequence) |
将序列中的元素用指定的字符连接生成一个新的字符串 |
1 >>> str = ("Python","程序","设计","案例","教程") 2 >>> s = "*" 3 >>> s.join(str) 4 'Python*程序*设计*案例*教程' |
| split() |
作用与join方法 相反 |
1 >>> str = "I love you !" 2 >>> str.split(" ") 3 ['I', 'love', 'you', '!'] |
| isalpha() |
用于检测字符串是否 只有字母和汉字组成 |
1 >>> str = "Python程序设计案例教程" 2 >>> str.isalpha() 3 True 4 >>> str = "Python 程序设计案例教程" 5 >>> str.isalpha() 6 False # 该字符串有空格 |
| isdigit() |
用于检测字符串是否只由数字组成 |
1 >>> str = "Python程序设计案例教程" 2 >>> str.isdigit() 3 False 4 >>> str = "1314520" 5 >>> str.isdigit() 6 True |
| lower() |
将字符全部转化为小写 |
1 >>> str = "i Love you" 2 >>> str.lower() 3 'i love you' |
| swapcase() |
讲字符串大小写互换 |
1 >>> str = "I Love You !" 2 >>> str.swapcase() 3 'i lOVE yOU !' |
| upper() |
将字符全部转化为大写 |
1 >>> str = "i Love you !" 2 >>> str.upper() 3 'I LOVE YOU !' |
| min() |
字符串最小值 |
1 >>> str = "I love you !" 2 >>> min(str) 3 ' ' |
| max() |
字符串最大值 |
1 >>> str = "I love you !" 2 >>> max(str) 3 'y' |
| len() |
计数字符串个数 |
1 >>> str = "I love you !" 2 >>> len(str) 3 12 |
| title() |
“标题化”该字符串 |
1 >>> str = "I love you !" 2 >>> str.title() 3 'I Love You !' |
| replace(old,new[,max]) |
用于把字符串中的旧字符串替换成新的字符串 max: 表示替换不超过max次 |
1 >>> str = "I do not love you !" 2 >>> str.replace(" do not "," ") 3 'I love you !' |
| translate() |
用法和replace方法相同，但不同的的是它只能替换一个字符 |
1 >>> str = "I love you !" 2 >>> str.translate(str.maketrans('LY','ly')) 3 'I love you !' |
| center() |
通过在两边添加填充字符（默认为空格）让字符串居中 |
1 >>> str = "I love you !" 2 >>> s = "*" 3 >>> str.center(20,s) 4 '****I love you !****' |
| strip() |
去除字符串开头和末尾的空格 |
1 >>> str = " I love you ! " 2 >>> str.strip() 3 'I love you !' |
导包
| 导包 |
说明 |
| from math import * sqrt(9) |
第一种导包 后面用起来更简洁 |
| from math import sqrt,pow,floor |
第二种导包（可同时导入多个包） |
| import math math.sqrt(9) |
第三种导包 |
| import math as shuxue shuxue.sqrt(9) |
导包同时可以用(as)重命名 |
| from math as shuxue import * |
没有这种，会报错 |
| from math import pow as pf pf(2,3) pow(2,3) |
导入特定的函数并给它指定别名 |
赋值
| 赋值 |
说明 |
||
| 序列解包 |
|||
| >>> x,y,z = 1,2,3 >>> print(x,y,z) 1 2 3 |
一起赋多个值 |
||
| >>> x,y,z = 1,2,3 >>> x,y = y,x >>> print(x,y,z) 2 1 3 |
两个变量值简易交换 |
||
1 >>> a,b,*rest = [1, 2, 3, 4] 2 >>> rest # [3, 4] 3 >>> a # 1 4 >>> b # 2 5 >>> c,d = rest 6 >>> c # 3 7 >>> d # 4 |
星号运算符（*）来收集多余的值，这样无需确保值和变量的个数相同 |
||
| 链式赋值 |
|||
1 >>> a = b = [1, 2] 2 >>> a == b 3 True 4 >>> a is b 5 True |
同等效果 |
1 >>> a = [1, 2] 2 >>> a = b 3 >>> a == b 4 True 5 >>> a is b 6 True |
|
1 >>> a = [1, 2] 2 >>> b = [1, 2] 3 >>> a == b 4 True 5 >>> a is b 6 False |
这样不是同一对象 |
||
常见语句
| 语句 |
说明 |
| pass |
空语句，主要为了保持结构的完整性。pass不做任何事情，一般用做占位语句 |
| continue |
跳出本次循环，执行下一次循环 |
| break |
终止循环 |
常用方法
| 函数 |
说明 |
案例 |
| range |
tart：计数从start开始。默认是从0开始。例如：range(5)等价于range(0,5) stop：计数到stop结束，但不包括stop。例如：range(0, 5)是[0, 1, 2, 3, 4]没有5 step：步长，默认为1。例如：range(0,5)等价于range(0,5,1) |
1 print("乘法口诀表：") 2 for x in range(1, 10): 3 for y in range(1, x+1): 4 print(y, "*", x, "=", x*y, end="\t\t") 5 print() |
| len |
方法返回对象（字符、列表、元组等）长度或项目个数。 |
|
| complex(real[,imag]) |
创建一个复数，其值为real + imag * j |
|
| dir([object]) |
返回object对象的属性名称列表。若没有指定参数object，则会返回现有的区域符号表（Loaal Symbol Table） |
|
| divmod(a,b) |
将a除以b的商与余数以元组类型返回，若a、b是整数或是长整数，返回值为(a/b,a%b), |
1 >>> divmod(5,3) 2 (1, 2) |
| exal(expression[,globals[,locals]]) |
运行expression表达式。global定义全局命名空间(global namespace),locals定义局部命名空间(locals namespace)。若没有locals参数，则使用globals定义值。若没有globals与locals参数，则使用单元本身的命名空间 |
|
| exec string [in globals[,locals]] |
运行包含Python程序代码的字符串string，globals与locals分别定义全局命名空间与局部命名空间 |
|
| id(object) |
返回object对象的唯一识别码，此识别码为一整数 |
1 >>> t = 9 2 >>> id(t) 3 1639045424 |
| int(x[, radix]) |
x为数值/字符串,若是字符串，可以设置radix值。radix是进制的基底值，可以是[2,36]之间的整数或0.若radix是0，则Python会根据字符串值进行判断。radix是用来说明x是几进制数 |
1 >>> int(100.5) 2 100 3 >>> int("100",8) 4 64 5 >>> int("100",16) 6 256 7 >>> int("100",0) 8 100 |
| max(s[,args...]) |
若只有一个参数，返回序数对象s中元素的最大值。如果有多个参数，返回最大的序数 |
1 >>> max(1,2,3,5,9) 2 9 3 >>> max("I love you !") 4 'y' 5 >>>max((1,2,3),(2,3),(1,2,4)) 6 (2, 3) |
| min(s[,args...]) |
若只有一个参数，返回序数对象s中元素的最小值。若有多个参数，返回最小的序数 |
1 >>> min(1,2,3,5,9) 2 1 3 >>> min("I love you !") 4 ' ' 5 >>>min((1,2,3),(2,3),(1,2,4)) 6 (1, 2, 3) |
| ord(c) |
返回单字符字符串c的ASCII或Unicode字符。若c是ASCII字符，ord()函数与chr()函数作用相反；若c是Unicode字符，ord()函数与unichr()函数作用相反 |
1 >>> ord("♥") 2 9829 3 >>> chr(9829) 4 '♥' |
| pow(x, y[, z]) |
若没有参数z返回xy，如果有z，则返回xy % z,y不能是负数 |
1 >>> pow(2,4) 2 16 3 >>> pow(2,4,5) 4 1 5 >>> pow(2,-1) 6 0.5 |
| tuple(sequence) |
使用sequence来创建一个元组对象。若sequence本身就是一个元组，其值不变 |
1 >>> tuple("love") 2 ('l', 'o', 'v', 'e') 3 >>> tuple(['l', 'o', 'v', 'e']) 4 ('l', 'o', 'v', 'e') |
用户自定义函数
1 # def 自定义函数名（形参1，形参2，…）： 2 # 函数体 3 # （return 返回值） 4 # 参数：1.必须参数2.关键字参数3.默认参数
1 # 自定义函数 2 def add(x, y): 3 result = x+y 4 return result 5 6 z1 = add(3, 5) # 必须参数传值 7 z2 = add(y=5, x=3) # 关键字参数传值 8 print("z1 = ", z1, ",z2 = ", z2) # z1 = 8 ,z2 = 8
__init__.py 文件的使用
1 import src.com.wx.ACM 2 # 欢迎来到IT决战空间，请展示您的代码效果了！ 3 # src.com.wx.ACM_file.__init__.py 4 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 5 6 import src.com.wx.PracticeTraining 7 # 欢迎来到IT决战空间，请展示您的代码效果了！ 8 # src.com.wx.PracticeTraining_file.__init__.py 9 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 10 11 import init 12 # 欢迎来到IT决战空间，请展示您的代码效果了！ 13 # src.com.wx.PracticeTraining.init_file.__init__.py 14 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Python日期和时间
python中时间日期格式化符号
| %y |
两位数的年份表示（00-99） |
| %Y |
四位数的年份表示（000-9999） |
| %m |
月份（01-12） |
| %d |
月内中的一天（0-31） |
| %H |
24小时制小时数（0-23） |
| %I |
12小时制小时数（01-12） |
| %M |
分钟数（00=59） |
| %S |
秒（00-59） |
| %a |
本地简化星期名称 |
| %A |
本地完整星期名称 |
| %b |
本地简化的月份名称 |
| %B |
本地完整的月份名称 |
| %c |
本地相应的日期表示和时间表示 |
| %j |
年内的一天（001-366） |
| %p |
本地A.M.或P.M.的等价符 |
| %U |
一年中的星期数（00-53）星期天为星期的开始 |
| %w |
星期（0-6），星期天为星期的开始 |
| %W |
一年中的星期数（00-53）星期一为星期的开始 |
| %x |
本地相应的日期表示 |
| %X |
本地相应的时间表示 |
| %Z |
当前时区的名称 |
| %% |
%号本身 |
1 import time 2 import calendar 3 def Calendar(): 4 year = int(time.strftime("%Y", time.localtime())) 5 month = int(time.strftime("%m", time.localtime())) 6 cal = calendar.month(year, month) 7 print(cal) 8 Calendar() 9 # July 2019 10 # Mo Tu We Th Fr Sa Su 11 # 1 2 3 4 5 6 7 12 # 8 9 10 11 12 13 14 13 # 15 16 17 18 19 20 21 14 # 22 23 24 25 26 27 28 15 # 29 30 31 16 17 print('北京时间:') 18 print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())) # 获取当前日期时间 19 # 北京时间: 20 # 2019-07-08 20:17:42
如有错误或不足，请留言，谢谢！
本文链接：https://www.cnblogs.com/AI-Star-Java/p/11718743.html
谢谢欣赏！关注一下！精彩不断！