Python基础学习资料（语法、函数详解）

谁践踏了优雅 2022-04-03 15:58 358阅读 0赞

目录  
目录 1  
常用函数 5  
input() 5  
int() 6  
len() 7  
list() 与tuple相对 8  
tuple() 与list相对 9  
sum() 10  
max() 11  
min() 12  
print() 13  
range() 14  
set() 15  
sorted() 16  
str() 17  
super()----用法暂时空。 18  
type() 19  
help() 20  
常用方法 21  
.title() 21  
.upper() 22  
.lower() 23  
.rstrip() 24  
.lstrip() 25  
.strip() 26  
.append() 27  
.insert() 28  
.pop() 29  
.remove() 30  
.sort() 31  
.reverse() 32  
.items() 33  
.keys() 34  
. values() 35  
.count() 36  
.extend() 37  
.index() 38  
.clear() 39  
.fromkeys() 40  
.get() 41  
.setdefault() 42  
.update() 43  
dict.pop()—字典专用.pop() 44  
.popitem() 45  
.readlines()—用法暂时为空。 46  
.write()—用法暂时为空 47  
.split()—用法暂时为空 48  
列表 49  
访问列表中的值 49  
删除列表中的值 49  
Python所包含的内置函数 49  
Python所包含的内置方法 49  
元组 51  
访问元组中的值 51  
修改元组中的值 51  
删除元组 51  
Python所包含的内置函数 53  
Python所包含的内置方法 53  
字典 54  
访问字典里的值 54  
修改字典 54  
删除字典（或者删除字典中的元素） 54  
Python所包含的内置函数 55  
Python所包含的内置方法 55  
Python循环 57  
while循环 57  
for循环 58  
break语句 59  
continue语句 59  
字符串 60  
Python转义字符 60  
字符串运算符 61  
字符串格式化 62  
Python自建函数 63  
语法 63  
定义一个函数 63  
创造一个无形参的参数 63  
创造一个有形参的参数 63  
位置实参 64  
关键字实参 64  
默认值 65  
返回值 65  
如何让参数变成可选的 65  
让函数可以接收列表进行操作 66  
传递任意数量的实参 66  
使用任意数量的关键字参数（形成字典） 67  
调用（封装到模块内的函数） 68  
import XXX 68  
from xxx import XXX 68  
使用as命令 68  
国际惯例 69  
类 70  
建立一个Dog类 70  
访问属性 71  
调用方法 71  
修改属性的值 71  
类的继承 72  
给子类添加一个新的属性和一个新的方法 72  
覆盖父类的方法 72  
导入类 73  
文件的操作 74  
读取文件 74  
写入文件 74

常用函数  
input()  
作用：输入-停止程序等待用户输入-输入结果为字符串。  
使用方法：  
n = input(‘请输入您的名字：’)  
print(‘您的名字是：’ + n)

int()  
作用：将内容转换为数据，数值。  
用法：  
n = ‘15’  
m = int(n)  
print(n)  
print(m)

len()  
作用：反馈长度函数，经常用于反馈列表等。  
语法：len(list)  
返回值：列表中元素的个数。  
用法：  
n = \[‘Audi’, ‘BMW’, ‘Benz’\]  
print(len(n))  
>>>  
3

>>>  
list() 与tuple相对  
作用：生成列表，或者转换为列表。  
语法：list(), list(tup)  
用法1：  
n = \[‘Audi’, ‘BMW’, ‘Benz’\]

用法2：  
n = (1, 2, 3, 4, 5)  
m = list(n)  
print(n)  
print(m)  
>>>  
(1, 2, 3, 4, 5)  
\[1, 2, 3, 4, 5\]

tuple() 与list相对  
作用：生成元组或者改变为元组。  
用法：  
n = \[1, 2, 3, 4, 5\]  
m = tuple(n)  
print(type(n))  
print(type(m))  
>>>  
<class ‘list’>  
<class ‘tuple’>

sum()  
作用：计算和值。  
用法：  
n = \[1, 2, 3, 4, 5, 6\]  
print(sun(n))  
>>>  
21

max()  
作用：取得最大值  
语法：max(list)，元组也可使用。  
返回值：返回最大值  
用法：  
n = \[1, 2, 3, 4, 5, 6\]  
print(max(n))  
>>>  
6

min()  
作用：取得最小值  
语法：min(list),元组也可使用。  
返回值：返回最小值。  
用法：  
n = \[1, 2, 3, 4, 5, 6\]  
print(min(n))  
>>>  
1

print()  
作用：打印内含文件。  
用法1：  
print(‘Hello,World’)

用法2：  
print(name.title() + ‘,欢迎您！’)

range()  
作用：生成序列，经常用于迭代操作。  
参数：rang(),函数可以指定步长。  
例如：rang(2,11,2),这个是2开始到11，每2进一次。（偶数列表）

用法：  
for n in range(1,6):  
print(n)  
>>>1  
>>>2  
>>>3  
>>>4  
>>>5  
set()  
作用：去重。  
返回值类型：返回值类型是一个‘集合’。  
用法：  
n = \[1, 2, 3, 4, 5, 5, 4, 3\]  
m = set(n)  
print(m)  
>>>\{1, 2, 3, 4, 5\}

sorted()  
作用：用于排序‘不改变原有列表’  
参数：含有参数reverse=True，可进行反向排序。  
用法：  
n = \[6, 3, 2, 1, 5, 5, 7, 3\]  
print(sorted(n))  
print(sorted(n, reverse = True))  
print(n)  
>>>  
\[1, 2, 3, 3, 5, 5, 6, 7\]  
\[7, 6, 5, 5, 3, 3, 2, 1\]  
\[6, 3, 2, 1, 5, 5, 7, 3\] \#用此函数，原有列表顺序不更改。 想更改重新赋值即可

str()  
作用：修改内容为字符串类型。  
用法：  
n = 23 \#此时变量n是int（整数型）  
m = str(n) \#则将n看作是字符串"  
print(type(n))  
print(type(m))  
>>>  
<class ‘int’>  
<class ‘str’>

super()----用法暂时空。  
作用：类的继承。  
用法：

type()  
作用：查看当前对象的类型。  
用法：  
n = \[1, 2, 3, 4, 5\]  
m = (1, 2, 3, 4, 5)  
o = \{1, 2, 3, 4, 5\}  
p = \{1:‘one’, 2:‘two’\}  
print(type(n))  
print(type(m))  
print(type(o))  
print(type§)  
>>>  
<class ‘list’>  
<class ‘tuple’>  
<class ‘set’>  
<class ‘dict’>

help()  
作用：帮助功能，查询函数的用法和参数设置。  
用法：  
help(print)

常用方法  
.title()  
作用：此方法用于所有单词进行大写的操作。  
用法：  
n = ‘shan mingqi’  
print(n.title())  
>>>  
Shan Mingqi

.upper()  
作用： 字母全部大写。  
用法：  
n = ‘shan mingqi’  
print(n.upper())  
>>>  
SHAN MINGQI

.lower()  
作用：字母全部小写，经常用于过滤用户输入的内容。  
用法：  
n = ‘SHAN MINGQI’  
print(n.lower())  
>>>  
shan mingqi

.rstrip()  
注意此方法不改变原有的值，如需改变请重新赋值。  
作用：删除字符串末尾的空白符。  
用法：  
n = ’ 此字符串左右各有两个空格 ’  
n = n.rstrip()  
n  
>>>  
’ 此字符串左右各有两个空格’

.lstrip()  
注意此方法不改变原有的值，如需改变请重新赋值。  
作用：删除字符串开头的空白字符。  
用法：  
n = ’ 此字符串左右各有两个空格 ’  
n = n.lstrip()  
n  
>>>  
'此字符串左右各有两个空格 ’

.strip()  
注意此方法不改变原有的值，如需改变请重新赋值。  
作用：删除字符串两端的空白字符。  
用法：  
n = ’ 此字符串左右各有两个空格 ’  
n = n.strip()  
n  
>>>  
‘此字符串左右各有两个空格’

.append()  
作用：添加新元素到列表最后的方法。  
语法：list.append(obj)  
参数：参数为添加的内容。  
返回值：此方法无返回值。  
用法：  
n = \[‘Audi’, ‘BMW’, ‘Benz’\]  
n.append(‘Tesla’)  
print(n)  
>>>  
\[‘Audi’, ‘BMW’, ‘Benz’, ‘Tesla’\]

.insert()  
作用：插入新的元素进入列表。  
语法：n.insert(索引，内容)  
参数：参数1为索引值，参数2为添加的内容。  
返回值：此方法无返回值。  
用法：  
n = \[‘Audi’, ‘BMW’, ‘Benz’\]  
n.insert(0, ‘Tesla’)  
print(n)  
>>>  
\[‘Tesla’, ‘Audi’, ‘BMW’, ‘Benz’\]

.pop()  
作用：弹出列表中的值，此方法删除列表值的同时可以进行一次赋值操作。返回值是所弹出的元素。  
语法：list.pop(\[index=-1\])  
参数：参数为索引值。  
返回值：返回值为列表中弹出的元素。  
系统默认参数为-1，即从最后一位弹出。  
用法1：  
n = \[‘Audi’, ‘BMW’, ‘Benz’\]  
m = n.pop()  
print(n)  
print(m)  
>>>  
\[‘Audi’, ‘BMW’\]  
Benz

用法2：  
n = \[‘Audi’, ‘BMW’, ‘Benz’\]  
m = n.pop(0)  
print(n)  
print(m)  
>>>  
\[‘BMW’, ‘Benz’\]  
Audi

.remove()  
注意：此方法由于返回值为None,所以使用关键字进行弹出列表中的内容的时候最好先对一个变量进行赋值，然后用这个变量进行操作。  
作用：弹出列表中的值。  
语法：list.remove(obj)  
参数：obj为要移除的元素  
返回值：此方法无返回值  
用法：  
n = \[‘Audi’, ‘BMW’, ‘Benz’\]  
z = ‘Benz’  
c = n.remove(z)  
print(n)  
>>>  
\[‘Audi’, ‘BMW’\]

.sort()  
作用：对列表进行永久排列顺序。  
语法：list.sort(cmp=None, key=None, reverse=False)  
参数：cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。  
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。  
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

返回值：此方法无返回值。  
用法1：  
n = \[‘Audi’,‘RR’, ‘Benz’\]  
n.sort()  
print(n)  
>>>  
\[‘Audi’, ‘Benz’, ‘RR’\]

用法2：  
n = \[‘Audi’,‘RR’, ‘Benz’\]  
n.sort(reverse = True)  
print(n)  
>>>  
\[‘RR’, ‘Benz’, ‘Audi’\]

.reverse()  
作用：列表内容直接进行反向排序（注意，此操作是直接反向排序，不是先按其他方式排序后再反向排序）。  
二次处理：如果想得到原来的列表，重新执行一次此方法即可。  
语法：list.reverse()  
返回值：此方法无返回值。  
用法：  
n = \[‘Audi’, ‘RR’, ‘Benz’\]  
n.reverse()  
print(n)  
n.reverse() \#反向在执行一次，即可得到原列表。  
print(n)  
>>>  
\[‘Benz’, ‘RR’, ‘Audi’\]  
\[‘Audi’, ‘RR’, ‘Benz’\]

.items()  
作用：遍历字典内键值对的方法。  
语法：  
参数：NA  
用法：  
n = \{‘型号：’: ‘A8’, ‘颜色：’: ‘black’, ‘停放位置：’: 125\}  
for k,v in n.items():  
print(‘关键字：’ + k)  
print(‘储存的数据：’ + str(v))  
>>>  
关键字：型号：  
储存的数据：A8  
关键字：颜色：  
储存的数据：black  
关键字：停放位置：

.keys()  
作用：以列表的方法，返回字典内所有键  
语法：dict.keys()  
参数：NA  
返回值：  
返回一个字典所有的键。  
用法1：  
n = \{‘姓名’: ‘单鸣祺’, ‘年龄’: 26\}  
print(n.keys())  
>>>  
dict\_keys(\[‘姓名’, ‘年龄’\])

用法2：  
n = \{‘型号：’: ‘A8’, ‘颜色：’: ‘black’, ‘停放位置：’: 125\}  
for k in n.keys():  
print(‘关键字：’ + k)  
>>>  
关键字：型号：  
关键字：颜色：  
关键字：停放位置：

. values()  
作用：字典，值的方法。  
参数：NA  
用法：  
n = \{‘型号：’: ‘A8’, ‘颜色：’: ‘black’, ‘停放位置：’: 125\}  
for v in n.values():  
print(‘值：’ + str(v))  
>>>  
值：A8  
值：black  
值：125

.count()  
作用：统计列表中某元素出现的次数。  
语法：list.count(obj)  
参数：为元素。  
返回值：返回元素在列表中出现的次数。  
用法：  
n = \[1, 2, 3, 4, 5, 5, 5, 5, 5, 6\]  
m = n.count(5)  
print(m)  
>>>  
5

.extend()  
作用：向列表中添加一个序列的元素到列表的末尾。  
语法：list.extend(seq)  
参数：seq为序列  
返回值：无  
用法：  
n = \[1, 2, 3, 4, 5, 5, 5, 5, 5, 6\]  
m = \[0, 0, 0\]  
n.extend(m)  
print(n)  
print(m)  
>>>  
\[1, 2, 3, 4, 5, 5, 5, 5, 5, 6, 0, 0, 0\]  
\[0, 0, 0\]

.index()  
作用：index() 函数用于从列表中找出某个值第一个匹配项的索引位置。  
语法：list.index(obj)  
参数：obj为查找的对象  
返回值：该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。  
用法：  
n = \[1, 2, 3, 4, 5, 5, 5, 5, 5, 6\]  
m = n.index(5)  
print(m)  
>>>  
4

.clear()  
作用：删除字典内的所有元素。  
语法：dict.clear()  
返回值：此方法无返回值。  
用法：  
n = \{‘姓名’: 川普’, ‘年龄’: 26\}  
n.clear()  
print(n)  
>>>  
\{\}

.fromkeys()  
作用：以seq序列为键，可选参数value为默认值，新建一个字典。  
语法：dict.fromkeys(seq\[, value\])  
参数：seq – 字典键值列表。  
value – 可选参数, 设置键序列（seq）的值。

返回值：返回值为新建的字典。  
用法：  
n = \[‘姓名’, ‘年龄’, ‘性别’, ‘体重’\]  
m = dict.fromkeys(n)  
c = dict.fromkeys(n, 10)  
print(m)  
print©  
>>>  
\{‘姓名’: None, ‘年龄’: None, ‘性别’: None, ‘体重’: None\}  
\{‘姓名’: 10, ‘年龄’: 10, ‘性别’: 10, ‘体重’: 10\}

.get()  
作用：查询键的值，如果查询的键不在字典中返回值为default内的值，默认为None  
语法：dict.get(key, default=None)  
参数：key – 字典中要查找的键。  
default – 如果指定键的值不存在时，返回该默认值值。

返回值：返回查询键的值，如果查询的键不在字典中返回值为default内的值，默认为None  
用法：  
n = \{‘姓名’: ‘川普’, ‘年龄’: 26\}  
print(n.get(‘姓名’, ‘查不到此信息’))  
print(n.get(‘性别’, ‘查不到此信息’))  
>>>  
川普查不到此信息

.setdefault()  
作用：.setdefault() [函数和g.et][g.et]() 方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。  
语法：dict.setdefault(key, default=None)  
参数：key为查询的关键字（如果查询不到则添加），第二参数为默认值。  
返回值：如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值。  
用法：  
n = \{‘姓名’: ‘川普’, ‘年龄’: 26\}  
n.setdefault(‘姓名’, ‘刘萌萌’)  
n.setdefault(‘性别’, ‘男’)  
print(n)  
>>>  
\{‘姓名’: ‘川普’, ‘年龄’: 26, ‘性别’: ‘男’\}

.update()  
作用：把字典dict2的键/值对更新到dict里。  
语法：dict.update(dict2)  
参数：dict2 – 添加到指定字典dict里的字典。  
返回值：此方法无返回值。  
用法：  
n = \{‘姓名’: ‘川普’, ‘年龄’: 26\}  
m = \{‘性别’: ‘男’\}  
n.update(m)  
print(n)  
print(m)  
>>>  
\{‘姓名’: '川普, ‘年龄’: 26, ‘性别’: ‘男’\}  
\{‘性别’: ‘男’\}

dict.pop()—字典专用.pop()  
作用：删除字典给定键 key 及对应的值，返回值为被删除的值。key 值必须给出。 否则，返回 default 值。  
语法：pop(key\[,default\])  
参数：key: 要删除的键值  
default: 如果没有 key，返回 default 值  
返回值：返回被删除的值,如未找到键则返回defalut的值。  
用法：

n = \{‘姓名’: ‘川普’, ‘年龄’: 26\}  
m = n.pop(‘年龄’)  
c = n.pop(‘性别’, ‘没有查询到此键’)  
print(n)  
print©  
>>>  
\{‘姓名’: ‘川普’\}  
没有查询到此键

.popitem()  
作用：随机删除一个键值对，如字典已经空了则报出异常。  
语法：dict.popitem()  
参数：NA  
返回值：随机删除一个键值对，如字典已经空了则报出异常。  
用法：  
n = \{‘姓名’: ‘川普’, ‘年龄’: 26\}  
n.popitem()  
print(n)  
n.popitem()  
print(n)  
n.popitem()  
print(n)  
>>>  
\{‘姓名’: ‘川普’\}  
\{\}  
Traceback (most recent call last):  
File “c:/Users/kadsm/OneDrive/Learning/Python/learn/2/验证想法.py”, line 6, in  
n.popitem()  
KeyError: ‘popitem(): dictionary is empty’

.readlines()—用法暂时为空。  
作用：从文件中读取每一行，并将它存在列表中。

.write()—用法暂时为空  
作用：写入文件的方法。

.split()  
作用：字符串方法，用于对字符串进行切片。  
根据一个字符创建一个列表。  
语法：str.split(参数1，参数2)  
参数1为分隔参数，以什么为界进行分隔。  
参数2为分割次数，例如一共5个t，如果设置分割次数为1，就第一个t被分割。  
用法：  
a = ‘[www.baidu.com][]’  
print(a.split(’.’))  
print(a.split(’.’, 1))  
>>>  
\[‘www’, ‘baidu’, ‘com’\]  
\[‘www’, ‘[baidu.com][]’\]

.repalce()  
作用： 字符串替换旧的字符串。  
语法： str.replace(old, new\[,max\])  
第一参数，老的字符，要被替换的。  
第二参数，新的字符，要替换的内容。  
第三参数，替换几次。  
用法：  
a = ‘There is apples’  
b = a.replace(‘is’, ‘are’)  
print(a)  
print(b)  
>>>There is apples  
>>>There are apples

列表  
列表在python里是一种序列，序列可以进行的操作包括：索引，切片，加，乘，检查成员（in和not in 返回布尔值）。  
列表的索引值是0开始的。

访问列表中的值  
语法：list\[索引值\]

删除列表中的值  
可以利用方法.pop(索引值\_默认值为-1)和.remove(关键字)，来删除。  
也可以使用del语句来删除，如下：  
n = \[‘Audi’, ‘RR’, ‘Benz’\]  
del n\[0\]  
print(n)  
del n\[:\]  
print(n)  
>>>  
\[‘RR’, ‘Benz’\]  
\[\]

Python所包含的内置函数  
函数名 作用 语法 备注  
cmp() 比较列表 cmp(list1, list2)  
len() 返回列表长度 len(list)  
max() 返回最大值 max(list)  
min() 返回最小值 min(list)  
list() 返回列表 list(tup)

Python所包含的内置方法  
方法名 作用 语法 备注  
.append() 向列表中添加元素 list.append(obj) 此方法没有返回值  
.count() 统计列表中某元素出现的次数 list.count(obj) 返回值为次数  
.extend() 想列表中添加一个序列的元素，添加到列表的末尾 list.extend(seq) 此方法没有返回值  
.index() 得到列表中某元素的第一个匹配项的索引值。 list.index(obj) 返回值为数字，是索引值。  
.pop() 弹出某个元素，默认弹出列表末尾最后一个。 list.pop(\[index=-1\]) 返回值为弹出的对象。  
.remove() 移除参数所设定的元素。 list.remove(obj) 此方法无返回值。  
.reverse() 永久改变列表中元素的顺序，改变标准是倒叙。如想得到原来列表，重新执行此操作即可。 list.reverse() 此方法无返回值。  
.sort() 对列表进行排序。  
参数用法请查看方法详情。 list.sort(cmp=None, key=None, reverse=False) 此方法无返回值。

元组  
元组在python里是一种特殊的序列，跟列表极其相似。最大的不同时不支持任何方法对其内部进行修改。元组标识为()小括号。

元组在python里是一种序列，序列可以进行的操作包括：索引，切片，加（连接符），乘，检查成员（in和not in 返回布尔值）。  
列表的索引值是0开始的。

Ps.特例：如果元组中只有一个元素请在元素后边添加,—例：n = (1, )

元组的索引从0开始  
访问元组中的值  
语法：tup\[索引值\]

修改元组中的值  
元组理论上是不支持修改的，但是我们可以通过重新赋值（给一个新的元组贴上老的标签）的方式修改。或者，如果有添加值得需求我们可以通过 + 运算符来合成两个元组。  
例1：  
n = (1, 2, 3, 4, 5, 5, 5, 5, 5, 6)  
n = (0,)  
print(n)  
>>>  
(0,)  
例2：  
n = (1, 2, 3, 4, 5, 5, 5, 5, 5, 6)  
m = (0,)  
c = n + m  
print©  
>>>  
(1, 2, 3, 4, 5, 5, 5, 5, 5, 6, 0)  
删除元组  
n = (1, 2, 3, 4, 5, 5, 5, 5, 5, 6)  
del n

Python所包含的内置函数  
函数名 作用 语法 备注  
cmp() 比较列表 cmp(tuple1, tuple2)  
len() 返回列表长度 len(tuple)  
max() 返回最大值 max((tuple)  
min() 返回最小值 min((tuple)  
list() 返回列表 list((tuple)

Python所包含的内置方法  
方法名 作用 语法 备注  
.count() 统计列表中某元素出现的次数 tuple.count(obj) 返回值为次数  
.index() 得到列表中某元素的第一个匹配项的索引值。 tuple.index(obj) 返回值为数字，是索引值。

字典  
字典是一种可变的容器，内部可储存任意格式的数据。  
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 \{\} 中。

字典的注意事项：

1.  值无限制，但是键只能在一个字典中出现一次，如果多次出现，后者覆盖前者。
2.  因为键必须是个确定值，所以键不能是列表。  
    访问字典里的值  
    n = \{‘Name’: ‘smq’, ‘age’: ‘26’\}  
    print(n\[‘Name’\])  
    print(n\[‘age’\])  
    >>>  
    smq  
    26

修改字典  
n = \{‘姓名’: ‘川普’, ‘年龄’: 26\}  
n\[‘年龄’\] = 27 \#修改值  
n\[‘性别’\] = ‘男’ \#添加新的键和值  
print(n)  
>>>  
\{‘姓名’: ‘川普’, ‘年龄’: 27, ‘性别’: ‘男’\}

删除字典（或者删除字典中的元素）  
一共三种，分别为：del dict\[key\]， .clear() , del dict  
1：  
n = \{‘姓名’: ‘川普’, ‘年龄’: 26\}  
del n\[‘年龄’\]  
print(n)  
>>>  
\{‘姓名’: ‘川普’\}

2：  
n = \{‘姓名’: ‘川普’, ‘年龄’: 26\}  
n.clear()  
print(n)  
>>>  
\{\}

3：  
n = \{‘姓名’: ‘川普’, ‘年龄’: 26\}  
del n

Python所包含的内置函数  
函数名 作用 语法 备注  
cmp() 比较列表 cmp(dict)  
len() 返回列表长度 len(dict) 返回的是键的个数

Python所包含的内置方法  
方法名 作用 语法 备注  
.clear() 清空字典 dict.clear() 此方法无返回值  
.fromkeys() 以seq序列为键，新建一个字典，可选参数value为默认值。 dict.fromkeys(seq\[, value\]) 此方法返回一个新的字典。  
.get() 返回指定键的值，如果值不存在则返回default内的值。 dict.get(key, default=None) 返回值为所查询键的值，如果查不到返回第二参数的内容默认为None  
.items() 此方法以列表的方式，返回可遍历的键值对。 dict.items() 返回可遍历的(键, 值) 元组数组。  
.keys() 返回一个列表的所有键。 dict.keys() 返回一个列表内所有键。  
.values() 返回一个列表的所有值。 dict.values() 返回一个列表的所有值。  
.setdefault() 和get方法类似，如果没查询到键，则添加这个键。 dict.setdefault(key, default=None) 如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值。  
.update() 添加一个字典2到字典1中去。 dict.update(dict2) 此方法无返回值。

.pop() 删除参数关键字的键值对。如果没有找到关键字则返回第二参数内的内容。 pop(key\[,default\]) 返回被弹出的键值，如果没有找到则返回第二参数的值。  
.popitem() 随机删除一个键值对，如果字典为空调用此方法则报出异常。 dict.popitem() 返回被删除的键值对，如果字典为空时执行此方法则报出异常。  
.has\_key()  
python3无此方法 查询某个键是不是在字典中是键。 dict.has\_key(key) 返回值为布尔值。

Python循环  
Python内置了3中循环体，分别为while循环，for循环和嵌套循环（就是在一个循环体中在嵌套一个循环体）  
Python还内置了，3中对循环进行控制的语句，分别是：break , continue , pass  
break语句用于终止循环过程，跳出循环。  
continue语句用于终止当前循环，重新开始循环。  
pass用于补充语法空白无实际意义。  
while循环  
\#设计一个打印双数的程序  
n = \[1, 2, 3, 4, 5, 6, 7, 8, 9\]  
d\_num = \[\]  
s\_num = \[\]  
while len(n) > 0:  
l\_num = n.pop()  
if l\_num % 2 == 0:  
d\_num.append(l\_num)  
else:  
s\_num.append(l\_num)

两个循环控制符的用法  
\#设计一个程序用于测试break和continue的用法。  
\#先用break来终止循环,程序是把双数打印一遍，到100的时候停止。  
i = 0  
while True:  
i += 1  
if i % 2 == 0:  
print(i)  
elif i % 2 != 0:  
pass  
if i > 100:  
break

for循环  
基本上就是用于遍历东西使用。

break语句  
Python break语句，就像在C语言中，打破了最小封闭for或while循环。  
break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。  
break语句用在while和for循环中。  
如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。  
\#设计一个程序用于测试break和continue的用法。  
\#先用break来终止循环,程序是把双数打印一遍，到100的时候停止。  
i = 0  
while True:  
i += 1  
if i % 2 == 0:  
print(i)  
elif i % 2 != 0:  
pass  
if i > 100:  
break

break语句，停止的是最深层的循环，就是说如果嵌套n层循环，想要停止所有循环就需要n个break语句。

continue语句  
\#再用continue的方式来打印单数。  
i = 0  
while i < 100:  
i += 1  
if i % 2 == 0:  
continue  
else:  
print(i)

continue重启的循环是最大的循环，就是说嵌套了n层循环，continue重启的是第一层最浅层，也就是最大的那个循环。

字符串  
Python转义字符  
在使用特殊符号的时候，可能需要对特殊符号进行转义，使其能为我们所用。  
转义字符 描述  
\\（在行尾时） 续行符  
\\ 反斜杠符号  
\\’ 单引号  
\\’’ 双引号  
\\a 响铃  
\\b 退格(Backspace)  
\\e 转义  
\\000 空  
\\n 换行  
\\v 纵向制表符  
\\t 横向制表符  
\\r 回车  
\\f 换页  
\\oyy 八进制数，yy代表字符，例如：\\o12代表换行  
\\xyy 十六进制数，yy代表字符，例如：\\x0a代表换行  
\\other 其他的字符以普通格式输出

字符串运算符  
以下实例，a为字符串’Hello’,b为’World’  
操作符 描述 实例

*  字符串连接 >>>a + b  
    ‘HelloWorld’

*  重复输出字符串 >>>a \* 2  
    ‘HelloHello’  
    \[\] 通过索引获取字符串中的字符 >>>a\[1\]  
    ‘e’  
    \[:\] 通过切片截取字符串中的一部分 >>>a\[1:4\]  
    ‘ell’  
    in 成员运算符，如果含有则返回True >>>“H” in a  
    True  
    not in 成员运算符，如果不含有则返回True >>>“M” not in a  
    True  
    r ‘xx’ 原始字符串，在字符串前加r，就是一切都按字面意思来，不存在任何其他东西。 print(r’\\n’)  
    >>>  
    \\n  
    % 格式字符串 见下一页

字符串格式化  
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。  
例如：  
name = ‘shan mingqi’  
age = 26  
print(‘姓名：%s,年龄：%d’ % (name,age))  
>>>  
姓名：shan mingqi,年龄：26

格式化操作符的含义  
符号 说明  
%c 格式化字符及其 ASCII 码  
%s 格式化字符串  
%d 格式化证书  
%o 格式化无符号的八进制数  
%x 格式化无符号的十六进制数  
%X 格式化无符号的十六进制（大写）  
%f 格式化浮点数字，可指定小数点的精度  
%e 用科学计数法格式化浮点数  
%E 作用通%e，用科学计数法格式浮点数  
%g 根据值的大小决定使用 %f 或 %e  
%G 作用同 %g，根据值的大小决定使用 %f 或者 %E  
%p 用十六进制数格式化变量的地址

格式化操作符的辅助指令

*  定义宽度或者小数点的精度

*  用作左对齐

*  在正数前边显示空格  
    在正数前边显示空格

# 在八进制数前边显示（'0’）,在十六进制前面显示’0x’或者‘0X’ #

0 在现实的数字面前填充’0’而不是默认的空格  
% %%输出一个单一的%  
(var) 映射变量（字典参数）  
m.n. m是显示的最小总宽度，n是小数点后的位数（如果可用的话）

Python自建函数  
语法  
def functionname( parameters ):  
‘’’函数\_文档字符串’’’  
function\_suite  
return \[expression\]  
定义一个函数  
你可以定义一个由自己想要功能的函数，以下是简单的规则：  
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。  
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。  
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。  
函数内容以冒号起始，并且缩进。  
return \[表达式\] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

创造一个无形参的参数  
def a():  
‘’‘调用这个函数就是打印‘大家好，我是一个打印参数’’’’  
print(‘大家好，我是一个打印参数’)  
a()  
>>>  
大家好，我是一个打印参数

创造一个有形参的参数  
def sum\_1(num\_1, \*num\_2):  
‘’‘这是一个求和函数，’’’  
sum\_s = 0  
for num\_z in num\_2:  
sum\_s += num\_z  
sum\_z = sum\_s + num\_1  
return sum\_z  
print(sum\_1(1,2,3,4,5))  
>>>  
15

位置实参  
通过位置来确定实参与形参的对应位置。  
def cars(car\_num, car\_type, car\_xinghao):  
‘’‘显示车辆信息’’’  
print(‘车辆编号是：’ + str(car\_num))  
print(‘车辆品牌是：’ + car\_type)  
print(‘车辆类型：’ + car\_xinghao)  
cars(‘No.001’, ‘奥迪’, ‘A8’)  
cars(‘No.002’, ‘奔驰’, ‘S600’)  
>>>  
车辆编号是：No.001  
车辆品牌是：奥迪  
车辆类型：A8  
车辆编号是：No.002  
车辆品牌是：奔驰  
车辆类型：S600

关键字实参  
通过关键字来确定实参和形参的关系，如果用此方法来编辑函数，是非常繁琐的但是这样定义实参和形参的关系是非常显而易见的，明确的。  
def cars(car\_num, car\_type):  
‘’‘显示车辆信息’’’  
print(‘车辆编号是：’ + str(car\_num))  
print(‘车辆品牌是：’ + car\_type)  
cars(car\_num = ‘No.001’, car\_type = ‘奥迪’)  
cars(car\_num = ‘No.002’, car\_type = ‘奔驰’)  
>>>  
车辆编号是：No.001  
车辆品牌是：奥迪  
车辆编号是：No.002  
车辆品牌是：奔驰

默认值  
我们可以在形参里定义好默认值，这样做有两点好处，1是在某种条件下可以减少实参的输入，2是可以避免忘记输入实参的时候不会报错。  
def cars(car\_num, car\_type=‘奥迪’):  
‘’‘显示车辆信息’’’  
print(‘车辆编号是：’ + str(car\_num))  
print(‘车辆品牌是：’ + car\_type)  
cars(‘No.001’)  
cars(car\_num = ‘No.001’)  
>>>  
车辆编号是：No.001  
车辆品牌是：奥迪  
车辆编号是：No.001  
车辆品牌是：奥迪

返回值  
每一个函数都有返回值，在编写函数的时候你可以自己定义函数的返回值，也可以不定义（这个时候返回值为None）。如果你的函数是执行某个动作或者某个操作，并没有返回值使用的必要，这时候你可以不写返回值。如果你的函数是在实参带入形参后进行了运算或者其他操作，最后返回某一个值，这时候你将需要自己定义一个返回值。  
def get\_formatted\_name(first\_name, last\_name):  
“”" 返回整洁的姓名 “”"  
full\_name = first\_name + ’ ’ + last\_name  
return full\_name.title()  
musician = get\_formatted\_name(‘jimi’, ‘hendrix’)  
print(musician)  
>>>  
Jimi Hendrix

如何让参数变成可选的  
有时候我们会遇到，参数为不确定项，可能要填写，可能不需要填写。这时候我们就需要定义一个可选形参，思路如下：给可选参数设定一个默认值，默认值为空。  
def car(pinpai, xinghao, yanse=’’):  
‘’‘这是一个打印车辆信息的函数，车辆的颜色为可  
选项，如果填写了则打印全部，如果不填写则不打印颜色’’’  
if yanse :  
print(pinpai,xinghao,yanse)  
else:  
print(pinpai,xinghao)

car(‘audi’, ‘a8’)  
car(‘audi’,‘a8’,‘black’)  
>>>  
audi a8  
audi a8 black

让函数可以接收列表进行操作  
def get\_renming\_gsh(listnames):  
‘’‘对列表内的用户进行问候,参数请传入列表’’’  
for a in listnames:  
print(‘欢迎光临：’ + a.title() + ‘!’)

n = \[‘peter’, ‘tony’, ‘jack’\]  
get\_renming\_gsh(n)  
>>>  
欢迎光临：Peter!  
欢迎光临：Tony!  
欢迎光临：Jack!

传递任意数量的实参  
def sum\_1(\*numbers):  
‘’‘传递任意数量的实参，进行求和’’’  
sum\_l = 0  
for num\_l in numbers:  
sum\_l += num\_l  
return sum\_l

print(sum\_1(1,2,3,4,5))  
>>>  
15  
另一种方法见上边“创造一个有形参的参数”  
使用任意数量的关键字参数（形成字典）  
def car\_info(pinpai, chexing, \*\*qita):  
car\_qita\_xinxi = \{\}  
car\_qita\_xinxi\[‘品牌’\] = pinpai  
car\_qita\_xinxi\[‘车型’\] = chexing  
for key, value in qita.items():  
car\_qita\_xinxi\[key\] = value  
return car\_qita\_xinxi  
n = car\_info(‘奥迪’, ‘A8’, 排量 = ‘4.2’, 车长 = ‘5500’)  
print(n)  
>>>  
\{‘品牌’: ‘奥迪’, ‘车型’: ‘A8’, ‘排量’: ‘4.2’, ‘车长’: ‘5500’\}

调用（封装到模块内的函数）  
我们经常把一类或者一个函数，封装到一个模块中（.py的程序），这样我们的主程序就可以减少代码量，显得更加简洁，把功能性的操作或者函数封装到独立的模块中。

import XXX  
语法：import xxx  
作用：导入xxx模块内的所有函数，此导入方式是隐形的你看不见的，当然你也不需要知道。在程序中调用的时候请使用’.’—点句号来调用。  
用法：  
①import XXX  
(省略扩展名)  
②XXX.函数名(参数)  
\---------例如---------  
import pizza  
pizza.make\_pizza(16, ‘芝士’)

from xxx import XXX  
语法：from xxx import XXX  
作用：导入xxx模块中的XXX函数，此函数可以使多个，中间用,隔开。在调用函数的时候直接使用函数名称即可，不用点句号’.’来使用。  
用法：  
\#例如现在有个模块，内含很多函数，我们只调用其中一个。  
from pizza import make.pizza\_0, make.pizza\_1, make.pizza\_2  
make.pizza\_0(16,‘芝士’）  
make.pizza\_1(16,‘芝士’, ‘大蒜’, ‘鳗鱼’)

使用as命令  
我们可以使用as命令来简化函数名称。  
from pizza import make\_pizza as mp  
mp(16, ‘芝士’, ‘大蒜’, ‘鳗鱼’)  
我们还使用as命令来简化模块名称，这样可以在调用函数的时候更加简洁。  
import pizza as p  
p.make\_pizza(16, ‘芝士’)  
国际惯例

1.  导入模块中所有函数还有一种语法： from XXX import \*  
    如果是导入模块中的函数，请使用import语句来导入模块，使用点句号来进行函数的调用这样代码易懂，便于维护。  
    如果强行使用from 语句来导入所有函数，在使用函数的时候是方便了，但是后期的维护将更加困难。
2.  在使用关键字实参的时候，请不要使用空格。
3.  在给定形参默认值的时候，请不要使用空格。
4.  代码长度不要过长，不要超过79个字符。
5.  如果编写模块的时候，会编写很多函数，请每个函数中间加两个空行。
6.  所有import语句请放在文件开头。

类  
在编程的时候可能会遇到一些，有共同特性的对象。python是一个面向对象编程的语言。我们在面对拥有很多相同对象的时候，我们就会使用类。

语法：  
class Xxx():  
def **init**(self, xx, xxx) \#\_\_init\_\_是一个特殊的方法，self是必要参数。

PS.我们创建类的时候使用的名称，首字母进行大写操作。

建立一个Dog类  
我们创建一个狗狗类，内含2个方法（翻身，和打滚），内含属性名字，年龄，品种，毛色。  
\#我们创建一个狗狗类，内含2个方法（翻身，和打滚），内含属性名字，年龄，品种，毛色。  
class Dog():  
def **init**(self, name, age):  
[self.name][] = name  
self.age = age  
self.pinzhong = None  
self.maose = None

def sit(self):
        '''执行坐下'''
        print('系统提示您：狗狗已经坐下了')
    
    def roll(self):
        '''执行打滚'''
        print('系统提醒您：狗狗正在打滚')
    
    def add_pinzhong(self, new_pinzhong):
        self.pinzhong = new_pinzhong
    
    def add_age(self, new_age):
        self.age = new_age

访问属性  
import dog  
n = dog.Dog(‘peter’, 16)  
print([n.name][])  
>>>  
peter

调用方法  
import dog  
n = dog.Dog(‘peter’, 16)  
n.sit()  
n.roll()  
>>>  
系统提示您：狗狗已经坐下了  
系统提醒您：狗狗正在打滚

修改属性的值  
方法1：  
import dog  
n = dog.Dog(‘peter’, 16)  
print(n.age)  
n.age = 18  
print(n.age)  
>>>  
16  
18

方法2：  
就是建立类的时候多建立一个能够直接修改值得方法，类似于上边的，add\_age()

类的继承  
我们经常需要建立一个类以后，会有新的需求这样可能会建立子类，用来继承很多父类已经拥有的属性和方法。  
语法：  
class Xxx(Xx):  
def **init**\_(self, name, age):  
super().**init**\_(name,age)  
用法  
class Dog():  
def **init**(self, name, age):  
.  
.  
.  
class Dog2ha(Dog):  
def **init**(self, name, age):  
super().**init**(name, age)

然后调用新子类的时候和之前的调用方法一样。

给子类添加一个新的属性和一个新的方法  
class Dog2ha(Dog):  
def **init**(self, name, age):  
super().**init**(name, age)  
self.sex = None

def add_sex(self, new_sex):
        self.sex = new_sex

覆盖父类的方法  
用相同的方法名称重写即可。

导入类  
导入单个类 from car import Car 如果导入子类，自带父类内容，无需导入父类。  
导入多个类 from car import Car, ElectricCar 导入多个类，用,分开。  
模块名.类名()  
导入整个模块 import car 下边调用类，需要使用点句表示法来调用。  
导入整个模块2 from car import \* 同函数模块调用函数一样，不要使用此方法导入模块。  
这里仅仅是为了能读懂而已，请不要使用。

文件的操作  
读取文件  
使用函数open()来打开文件。  
还可以是用close()来关闭文件。方法：(file.close())，关闭文件。  
注意关闭文件的时候要分情况，如果流程中可能会多次用到文件，则不关闭，等待python的回收机制自动关闭。如果是大型服务可能会出现，必须手动关闭的情况，如果不手动关闭可能造成资源的流失和浪费甚至是服务器资源的耗尽。

语法：  
with open(‘xxx.txt’) as file\_object:  
contents = file\_object.read()  
print(contents)

如果文件不在根目录，则  
file\_lujing = ‘E:\\OneDrive\\Learning\\Python\\learn\\2\\123.txt’  
with open(file\_lujing) as file\_object:  
contents = file\_object.read()  
print(contents)

写入文件  
使用open()函数的第二参数，可选参数为(w,r,a)  
w为写入，注意此写入会覆盖原有文件。  
r为只读模式。  
a为附加模式，此模式会把写入的东西附加到末尾。  
open()函数里添加一个实参’w’  
写入模式 with open(‘password.txt’, ‘w’) as pass\_oj:  
pass\_oj.write(‘siaa1111\\n’)  
pass\_oj.write(‘siaa2222\\n’)  
pass\_oj.write(‘siaa3333\\n’)  
open()函数里添加一个实参’r’  
只读模式 省略  
open()函数里添加一个实参’a’  
附加模式 with open(‘password.txt’, ‘a’) as pass\_oj:  
pass\_oj.write(‘siaa1111\\n’)  
pass\_oj.write(‘siaa2222\\n’)  
pass\_oj.write(‘siaa3333\\n’)

JSON  
Python内置的JSON库，仅有两种函数（方法）。

json.dumps(): 对数据进行编码。  
json.loads(): 对数据进行解码。

RE正则表达式  
正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

re.match函数  
re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

语法：re.match(pattern, string, flags=0)  
使用方法：pattern是匹配的正则表达式  
string是要匹配的字符串  
flage是标志位，用于控制正则表达式的匹配方式，比如：是否区分大小写，多行匹配等等。详见，正则表达式修饰符-可选标志。.  
返回值：如果匹配成功了，就返回匹配的对象，否则则返回none

匹配对象方法 描述  
group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。  
groups() 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

[g.et]: http://xn--g-cc8ap2ff91a.et
[www.baidu.com]: http://www.baidu.com
[baidu.com]: http://baidu.com
[self.name]: http://self.name
[n.name]: http://n.name