python基础语法部分
一、程序的基本格式
1.1 缩进
1.使用tab制表符或空格表示缩进，默认为一个制表符或4个空格为一个层级。（编辑器可自动调整tab为四个空格）
2.同一程序内缩进数量应保持一致。
age = int(input("请输入您的年龄："))
if abs(age) >= 18: print("您已成年")
else: print("您还是未成年")
- 1
- 2
- 3
- 4
- 5
1.2 大小写
python区分大小写，python和Python代表两个对象。
1.3 注释
注释表示该语句在程序运行时不被执行。单行注释使用【# 注释语句】，多行注释采用【’’'注释语句‘’‘】。
name = "杰尼龟"
name = "水箭龟"
Name = "皮卡丘"
print(name) #结果为水箭龟
print(Name) #结果为水卡丘
'''python里区分大小写，变
量命名时应注意使用'''
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
1.4 行连接符及【;】的使用
python中一行代码过长时可在想换行处使用行连接符【\】，进行换行编写。程序还是会认为它在同一行。
print("随便打一串文\
字做一下测试")
- 1
- 2
如果想把几行代码写为一行，可用【；】进行连接。
num = 2 ; result = num + 3
print(result)
- 1
- 2
4.转义字符
Python 支持的转义字符
| 字符 | 含义 | 字符 | 含义 |
|---|---|---|---|
| \ | 换行符 | \ t | 制表符 |
| \ \ | 反斜线 | \ b | 退格符 |
| \ n | 换行符 | \ r | 回车符 |
| \ ‘ | 单引号 | \ “ | 双引号 |
二、程序的构成
2.1 对象
python中一切皆对象
1.每个对象皆有对应的标识（id）、类型（type）、值（value）。
2.变量通过存储对象ID对其进行引用。
3.对象只能进行与其类型对应相关操作。
2.2 标识符
用于变量、函数、类、模块等的名称
命名规则：
a.区分大小写。如：zxl和Zxl是不同的；
b.第一个字符必须是字母、下划线。其后字符是字母、下划线、数字；
c.不能使用关键字，如：if、elif、or等；
d.以双下划线开头和结尾的名称通常由特殊含义，尽量避免此种写法。如：__init__是类的构造函数。
python保留字符（仅包含小写字母部分）
| and | exec | not |
| assert | finally | or |
| break | for | pass |
| class | from | |
| continue | global | raise |
| def | if | return |
| del | import | try |
| elif | in | while |
| else | is | with |
| except | lambda | yield |
特殊命名约定
| 类型 | 规则 | 举例 |
|---|---|---|
| 模块名、包名 | 全小写字母，尽量简单，若多个单词用下划线链接 | math、time、os |
| 函数名 | 全小写字母，若多个单词用下划线链接 | say_hi、sum_num |
| 类名 | 单词首字母大写，采用驼峰原则 | My_Name |
| 常量名 | python不支持常量。只能通过逻辑控制对象为一个常量，采用全大写 | MY_NAME |
2.3 变量（变量作用域：全局变量、局部变量详见扩充部分）
程序就是用来处理数据的，而变量就是用来引用数据的；python中的变量不需要指明类型，系统会自动识别。
变量的初始化（赋值）
利用【=】号进行赋值：变量名 = 表达式
a = "杰尼龟" #id = 1612667500272 type:str
print(id(a),type(a))
- 1
- 2
python执行程序从上往下执行，如果后续代码中为变量重新指代了值，以前的那个值会被替换，并被python进行垃圾回收。
变量的赋值方式
链式赋值：将一个对象同时赋值给多个变量。
变量1 = 变量2 = 对象1
a = b = "杰尼龟"
print(a,b) #结果为杰尼龟 杰尼龟
- 1
- 2
解包赋值
解包赋值可使用列表、元组、字典。方便我们对多个变量进行赋值
元组解包
(a , b , c) = (1 , 2 , 3) #等同于 a,b,c = 1,2,3
print(a , b , c) #结果为1 2 3
- 1
- 2
列表解包
[a,b,c] = [[1,2],3,[4,5]]
print(a) #结果为[1, 2]
print(b) #结果为3
print(c) #结果为[4, 5]
- 1
- 2
- 3
- 4
字典解包：字典解包时，默认是对键进行操作。如果想对值进行解包赋值，需使用values(),如果是想对键值对整体赋值，需使用items()（返回结果为元组类型）。
s = {"name":"杰尼龟","age":18,"color":"yellow"}
a,b,c = s
print(a,b,c) #结果为name age color
a,b,c = s.values()
print(a,b,c) #结果为杰尼龟 18 yellow
a,b,c = s.items()
print(a,b,c) #结果为('name', '杰尼龟') ('age', 18) ('color', 'yellow')
- 1
- 2
- 3
- 4
- 5
- 6
- 7
变量值互换
变量1，变量2 = 对象1 ，对象2
变量1，变量2 = 变量2 ， 变量1
a , b = 1 , 2
a , b = b , a
print(a,b) #结果为2 1
- 1
- 2
- 3
删除变量
可通过del删除不再使用的变量。
a = b = "杰尼龟"
del a
print(b) #结果为杰尼龟
print(a) #抛出异常：name 'a' is not defind
- 1
- 2
- 3
- 4
变量删除后，变量指代的对象依然存在，但是没有变量引用的对象会被python垃圾回收器回收，清除内存空间
2.5 程序的输入与输出
输入函数
python利用内置函数input()来获取控制台键盘输入的内容，并将内容存储于变量。
【变量 =input(“提示信息”) 】
age = input("请输入您的年龄：")
print(type(age)) #结果为<class 'str'>
- 1
- 2
获取到的数据会存储为字符串类型
打印函数
python通过print()函数将程序运行结果输出值控制端。
【print(想要输出的结果，end = “任意字符串”)】
age = input("请输入您的年龄：") #输入25
print(type(age)) #结果为<class 'str'>
print(age) #结果为25
- 1
- 2
- 3
逗号后可不写，不写则为默认的end = “\n”
不换行打印
调用print()函数时默认结尾为换行符，可调整为其他字符串，使函数进行不换行打印。
a , b = 1 , 2
print(a,end="**") #结果为1**2（在同一行，不会换行）
print(b) #如不加end=str，默认为end= "\n"
- 1
- 2
- 3
三、基本数据类型
3.1 布尔型（bool）
1.布尔值的创建
布尔型中只有True和False两个值，表示真和假（注意大小写）；
2.布尔值的运算
a.作为布尔值使用时通常搭配逻辑运算符与（and）或（or）非（not）进行使用。
b.也可做为数字1和0使用（True为1，False为0）。
#and：一假返回假，or:一真返回真,not :返回相反值
print(True and True) #结果为True
print(True and False) #结果为False
print(False and False) #结果为False
print(True or True) #结果为True
print(True or False) #结果为True
print(False or False) #结果为False
print(not False) #结果为True
print(not True) #结果为False
print(True + 1) #结果为2
print(False + 1) #结果为1
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
3.2 数字型
1.整数型（int）
即为数学上的整数，例如：1，2，25，30等。
2.浮点型（float）
即为数学上的小数，包含.0小数，例如1.5，2.83，17.0等。
3.算术运算符
以下假设变量 a=10，b=20：
当整数与浮点数进行运算时，返回的值默认为浮点数。
a , b = 2 , 2.5
print(type(a * b)) #结果为<class 'float'>
- 1
- 2
4.数字格式化
下表展示了 str.format() 格式化数字的多种方法：
a = 3.1415926
print("{:.2f}".format(a)) #结果为3.14
- 1
- 2
| 数字 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| 3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
| -1 | {:+.2f} | -1.00 | 带符号保留小数点后两位 |
| 2.71828 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为2) |
| 5 | {:x<4d} | 5xxx | 数字补x (填充右边, 宽度为4) |
| 10 | {:x<4d} | 10xx | 数字补x (填充右边, 宽度为4) |
| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00e+09 | 指数记法 |
| 13 | {:>10d} | 13 | 右对齐 (默认, 宽度为10) |
| 13 | {:<10d} | 13 | 左对齐 (宽度为10) |
| 13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
| 11 | '{:b}'.format(11)
'{:d}'.format(11)
'{:o}'.format(11)
'{:x}'.format(11)
'{:#x}'.format(11)
'{:#X}'.format(11) |
1011 11 13 b 0xb 0XB |
进制 |
^，<，>分别是居中、左对齐、右对齐，后面带宽度，: 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+表示在正数前显示+，负数前显示-，（空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
5.其他操作
divmod()函数：同时得到商和余数。
a = 10
b = 3
print(divmod(a,b)) #结果为元组（3，1）
- 1
- 2
- 3
round()函数：将浮点数四舍五入。
a = 3.678
print(round(a))#结果为4
- 1
- 2
chr()：用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符（参数可以是16进制或者10进制）。
a = 66 #十进制
b = 0x68 #十六进制
print(chr(a)) #结果为B
print(chr(b)) #结果为B
- 1
- 2
- 3
- 4
3.3 字符串型（str）
是一种不可变的字符序列：后续所有拼接/修改操作均为形成新的字符串数据（标点符号及空格也是字符）。
1.字符串的创建
利用单引号（‘xxx’）/双引号（“xxx”）进行创建。
a = '杰尼龟' ; b = "可达鸭"
c = "my name is '杰尼龟'"
print(type(a),type(b)) #结果为<class 'str'>
- 1
- 2
- 3
多行字符串（‘’‘xxxxxxx’’’)进行创建。
a = '''杰
尼
龟'''
print(type(a)) #结果为<class 'str'>
- 1
- 2
- 3
- 4
2.字符串的拼接
使用【+】号进行拼接，生成一个新的拼接后的字符串对象。
a ,b , c= '杰尼龟' , "可达鸭" ,111
print(a + str(c) + b)#结果为杰尼龟111可达鸭
- 1
- 2
直接字符串相接也可拼接
c= '杰尼龟' '暴打'"可达鸭"
print(c)#结果为杰尼龟暴打可达鸭
- 1
- 2
“”.join(list)：将列表中字符串用特定字符拼接起来，不指定字符默认为直接拼接。
a = ['我', '叫', '杰', '尼', '龟']
print("".join(a)) #结果为我叫杰尼龟
print("*".join(a)) #结果为我*叫*杰*尼*龟
- 1
- 2
- 3
使用【+】，每【+】一次会形成一个新的对象。使用join在拼接字符串之前会计算所有字符串的长度，然后逐一拷贝，仅新建一次对象。大型运算时推荐使用join
3.字符串的复制
字符串可直接使用乘法运算符进行复制
c = '杰尼龟'
print(c * 3)#结果为杰尼龟杰尼龟杰尼龟
- 1
- 2
4.检查字符串
str.isdigit()：检查字符串内部是否全部是数字，返回True或False。
c = '123456'
print(c.isdigit())#结果为True
c = '123 456'
print(c.isdigit())#结果为False
- 1
- 2
- 3
- 4
str.isalpha()：检查字符串内部是否全是字母，返回True或False。
c = 'asdfgh'
print(c.isalpha())#结果为True
c = 'asdfgh123'
print(c.isalpha())#结果为False
- 1
- 2
- 3
- 4
str.isupper()：检查字符串内部是否全是大写字母，返回True或False。
c ='ASDFGH'
print(c.isupper())#结果为True
c = 'asdfgh'
print(c.isupper())#结果为False
- 1
- 2
- 3
- 4
str.islower()：检查字符串内部是否全是小写字母，返回True或False。
c ='asdfgh'
print(c.islower())#结果为True
c ='ASDFGH'
print(c.islower())#结果为False
- 1
- 2
- 3
- 4
str.endswith()：检查字符串内部是否以指定字符串结尾，返回True或False。
c ='asdfgh'
print(c.endswith("gh"))#结果为True
- 1
- 2
str.startswith()：检查字符串内部是否以指定字符串开头，返回True或False。
c ='ASDFGH'
print(c.startswith("AS"))#结果为True
- 1
- 2
str.isspace()：检查字符串内部是否全是空格，返回True或False。
c =' '
print(c.isspace())#结果为True
- 1
- 2
5.查找字符串
len()：查找字符串的长度，返回长度数值。
c ='123456789'
print(len(c))#结果为9
- 1
- 2
str.find()：查找指定字符在字符串中从左往右第一次出现的位置，有则返回字符下标（编号），没有返回-1。
c ='123456789'
print(c.find("3"))#结果为2
print(c.find("10"))#结果为-1
- 1
- 2
- 3
str.rfind()：查找指定字符在字符串中从右往左第一次出现的位置，有则返回字符下标（编号），没有返回-1。
c ='1234567289'
print(c.rfind("2"))#结果为7
print(c.rfind("10"))#结果为-1
- 1
- 2
- 3
str.index()：查找指定字符在字符串中第一次出现的位置，有则返回字符下标（编号），没有抛出异常。
c ='123456789'
print(c.index("9"))#结果为8
print(c.index("10"))#结果为ValueError: substring not found
- 1
- 2
- 3
str.count()：查找指定字符在字符串中总共出现次数，返回数量。
c ='123456789123465184'
print(c.count("1"))#结果为3
print(c.count("10"))#结果为0
- 1
- 2
- 3
6.“修改”字符串
python中字符串本身为不可修改类型，所有修改操作均为创建新的对象，原字符串不做改变。
str.replace(“old”,“new”)：使用指定字符替换字符串中对应字符。
a = "hello world"
print(a.replace("o","0"))#结果为hell0 w0rld
- 1
- 2
str.upper()：将字符串内部字母转换为大写字母。
a = "12345asdf"
print(a.upper())#结果为12345ASDF
- 1
- 2
str.lower() ：将字符串内部字母转换为小写字母。
a = "12345ASDF"
print(a.lower())#结果为12345asdf
- 1
- 2
str.capitalize()：将一个字符串的第一个字符改为大写字母，其余字母变小写。如果第一个字符不是字母，则仅将后续字母改为小写。
a = "12345ASDF"
print(a.capitalize())#结果为12345asdf
a = "a2345ASDF"
print(a.capitalize())#结果为A2345asdf
- 1
- 2
- 3
- 4
str.split()：将字符串按照指定字符进行分割为多个字符串并存储在列表中，如不指定字符，默认为空格、换行符、制表符。
a = "我 叫 杰 尼 龟"
b = "我*叫*杰*尼*龟"
print(a.split())#结果为['我', '叫', '杰', '尼', '龟']
print(b.split("*"))#结果为['我', '叫', '杰', '尼', '龟']
- 1
- 2
- 3
- 4
str.title()：将字符串中每个单词的首字母大写，其余改为小写
a = "my name"
b = "MY NAME"
print(a.title())#结果为My Name
print(b.title())#结果为My Name
- 1
- 2
- 3
- 4
str.swpacase()：将字符串中所有字母大小写互换
a = "My Name"
print(a.swapcase())#结果为mY nAME
- 1
- 2
str.strip()：将字符串中首尾的指定字符去除
a = '**杰尼*龟*'
print(a.strip("*")) #结果为杰尼*龟
- 1
- 2
str.lstrip()：将字符串中左侧的指定字符去除
a = '**杰尼*龟*'
print(a.lstrip("*")) #结果为杰尼*龟*
- 1
- 2
str.rstrip()：将字符串中左侧的指定字符去除
a = '**杰尼*龟*'
print(a.rstrip("*")) #结果为**杰尼*龟
- 1
- 2
eval()：去除首尾引号，并执行余下语句
a = '123'
print(eval(a)+2) #结果为125
- 1
- 2
ord()：将单字符串转换为对应的Unicode编码
a = "杰"
print(ord(a)) #结果为26480
- 1
- 2
7.字符串排版
str.center(num,“x”)：填充x字符使字符串达到num长度，并将其居中
a = "杰"
print(a.center(5,"*")) #结果为**杰**
- 1
- 2
str.ljust(num,“x”)：填充x字符使字符串达到num长度，并将原字符串居左
a = "杰"
print(a.ljust(5,"*")) #结果为杰****
- 1
- 2
str.rjust(num,“x”)：填充x字符使字符串达到num长度，并将原字符串居右
a = "杰"
print(a.rjust(5,"*")) #结果为****杰
- 1
- 2
8.format()函数的应用
使用示例
a = "杰尼龟"
b = "可达鸭"
print("{}暴打{}".format(a,b)) #结果为杰尼龟暴打可达鸭
print("{0}暴打{0}".format(a,b)) #结果为杰尼龟暴打杰尼龟
print("{0}暴打{1}".format(a,b)) #结果为杰尼龟暴打可达鸭
print(f"{a}暴打{b}") #结果为杰尼龟暴打可达鸭
- 1
- 2
- 3
- 4
- 5
- 6
format()函数
print("{0}*{1}={2:*<7}".format(3,2,2*3))
- 1
位置索引
关键字映射
元素访问
填充对齐
a , b , c = "杰尼龟" , "可达鸭" , "杰尼龟"
print("{0:*^7}使用火箭头槌暴打{1:*>7}和{2:*<7}".format(a,b,c))
#结果为**杰尼龟**使用火箭头槌暴打****可达鸭和杰尼龟****
- 1
- 2
- 3
【^，<，>】分别是居中、左对齐、右对齐，后面带宽度，: 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
9.字符串索引操作
str[num]：找到字符串指定位置的字符。
标点符号及空格也是字符
a= "my name is '杰尼龟'"
print(a[3]) #结果为n
- 1
- 2
10.字符串切片操作
str[x:y:±step]：从编号x到编号y之前，从左到右或从右到左以step间隔取值
在切片操作中，起始终止编号不在[0:字符串长度-1]这个范围内也不会报错，超过0或末端按0和末端截取
3.4类型转换
在python中可使用内置函数对数据类型进行类型转换：
① str()：将数据转换为字符串类型；
a , b , c ='123',456,789.5
print(str(b)) ; print(str(c)) #结果为'456' 、 '789.5'
- 1
- 2
② float()：将纯数字字符串或整数转换为浮点数；
a , b , c ='123',456,789.5
print(float(a)) ; print(float(b)) #结果为123.0 、 456.0
- 1
- 2
③ int()：将纯数字字符串或浮点数转换为浮点数。
a , b , c ='123',456,789.5
print(int(a)) ; print(int(c)) #结果为123 、 789
- 1
- 2
int()函数转换是直接去掉小数点，而不是四舍五入
四、运算符
1.比较运算符
比较运算符运算结果返回True和False。
假设:a = 15 ; b = 20
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于：比较两个对象值是否相等 | a == b；返回False |
| != | 不等于：比较两个对象值是否不相等 | a != b；返回True |
| > | 大于：比较两个对象值的大小关系 | a > b；返回False |
| < | 小于：比较两个对象值的大小关系 | a < b；返回True |
| >= | 大于等于：比较两个对象值的大小关系 | a >= b；返回False |
| <= | 小于等于：比较两个对象值的大小关系 | a <= b；返回True |
2.逻辑运算符
与（and）、或（or）、非（not）
| 运算符 | 实例 | 说明 |
|---|---|---|
| and | x and y | x为True，计算并返回y的值。x为False，不计算y，返回False |
| or | x or y | x为True，不计算y，返回True。x为False，计算并返回y的值 |
| not | not x | x为True，返回False。x为False，返回True |
3.身份运算符
is、not is比较两个对象的id是否一致
| 运算符 | 实例 | 说明 |
|---|---|---|
| is | 比较两个对象地址是否一致 | x is y ：‘类似于id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| not is | 比较两个对象地址是否一致 | x not is y ：‘类似于id(x) != id(y) , 如果引用的不是同一个对象则返回 True，否则返回 False |
4.成员运算符
in、not in判断对象是否在对象内部
| 运算符 | 实例 | 说明 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中未找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
5.算术运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 30 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
| / | 除 - x除以y | b / a 输出结果 2 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 0 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的20次方， 输出结果 100000000000000000000 |
| // | 取整除 - 返回商的整数部分（向下取整） | >>> 9//2 4 >>> -9//2 -5 |
6.赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
7.位运算符（我也不知道这咋用）
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
下表中变量 a 为 60，b 为 13，二进制格式如下：
a = 0011 1100
b = 0000 1101
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
8.Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符：
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is not is | 身份运算符 |
| in not in | 成员运算符 |
| not and or | 逻辑运算符 |
五、列表（list）
列表是一种python内置可变序列，用来存储不限数量、不限类型的数据集合。
1.列表的创建
方括号创建
方括号内添加数据，使用【，】逗号隔开
l = [1,2,3,"杰尼龟","可达鸭",True,False]
print(type(l)) #结果为<class 'list'>
- 1
- 2
生成器推导式创建：利用for循环加条件判断创建想要的列表
l = [i for i in range(5)]
print(l) #结果为[0, 1, 2, 3, 4]
l = [i+5 for i in range(5) if i <=3]
print(l) #结果为[5, 6, 7, 8]
- 1
- 2
- 3
- 4
list()函数创建
使用list函数将可迭代数据转换为列表
l = list("杰尼龟暴打可达鸭")
print(l) #结果为['杰', '尼', '龟', '暴', '打', '可', '达', '鸭']
- 1
- 2
使用list函数将range函数转换为列表：创建整数序列（开始默认为0，步长默认为1），步长正数从小往大数，步长负数从大往小数。开始结束数值应满足大小关系，否则返回空列表
l = list(range(5))
print(l) #结果为[0, 1, 2, 3, 4]
l = list(range(3,10,2))
print(l) #结果为[3, 5, 7, 9]
l = list(range(10,3,-2))
print(l) #结果为[10, 8, 6, 4]
l = list(range(3,10,-2))
print(l) #结果为[]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
2.增加元素
list.append()：在列表末尾添加单个元素（速度最快，推荐使用）。
l = [1]
l.append("10")
print(l) #结果为[1, '10']
- 1
- 2
- 3
list.extend(list1)：将list1添加到list尾部。
l = [1]
l1 = ["10"]
l.extend(l1)
print(l) #结果为[1, '10']
- 1
- 2
- 3
- 4
list.extend(list1)：将list1添加到list尾部。
l = [1]
l1 = ["10"]
l.extend(l1)
print(l) #结果为[1, '10']
- 1
- 2
- 3
- 4
list.insert()：在列表指定位置添加单个元素。
l = [1,2,3,4,5]
l.insert(3,5)
print(l) #结果为[1, 2, 3, 5, 4, 5]
- 1
- 2
- 3
以上操作均为原地修改，不产生新对象
list1 + list2 ：将列表2添加到列表1尾部（会产生一个新的列表对象，原列表不会改变）。
l = [1,2,3,4,5]
l1 = [6,7,8,9,10]
l2 = l + l1
print(l) #结果为[1, 2, 3, 4, 5]
print(l2) #结果为[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
- 1
- 2
- 3
- 4
- 5
list * num ：将原列表复制num份并合并成一个新列表（会产生多个新的列表对象，原列表不会改变）。
l = [1,2,3]
l1 = l * 3
print(l) #结果为[1, 2, 3]
print(l1) #结果为[1, 2, 3, 1, 2, 3, 1, 2, 3]
- 1
- 2
- 3
- 4
利用切片添加添加成段元素
a = [1,2,3,6]
b = [4,5]
a[2:2] = b
print(a) #结果为[1, 2, 4, 5, 3, 6]
- 1
- 2
- 3
- 4
3.删除元素
del list[num] ：删除列表指定位置的元素。如不指定位置则为删除列表本身。
l = [1,2,3]
del l[2]
print(l) #结果为[1, 2]
del l
print(l) #结果为name 'l' is not defined
- 1
- 2
- 3
- 4
- 5
list.clear() :清除列表中所有元素，不是删除列表本身。
l = [1,2,3]
l.clear()
print(l) #结果为[]
- 1
- 2
- 3
list.pop()：提取出列表指定位置的元素，留作他用。
l = [1,2,3]
a = l.pop(1)
print(l) #结果为[1, 3]
print(a) #结果为2
- 1
- 2
- 3
- 4
list.remove()：删除指定元素在列表中第一次出现的位置，如没有该元素则抛出异常。
l = [1,2,3,4,3,5]
l.remove(3)
print(l) #结果为[1, 2, 4, 3, 5]
- 1
- 2
- 3
4.查找元素
len(list)：查找列表中元素数量，返回数量值。
l = [1,2,3,4,3,5]
print(len(l)) #结果为6
- 1
- 2
sum(list)：纯数字列表求和，返回一个求和的值。
a = [1,2,3,4,5,6,7,8,9]
print(sum(a)) #结果为45
- 1
- 2
max(list)：查找列表中最大值，返回最大值元素。
a = [1,2,3,4,5]
print(max(a)) #结果为5
- 1
- 2
min(list)：查找列表中最小值，返回最小值元素。
a = [1,2,3,4,5]
print(min(a)) #结果为1
- 1
- 2
list.index(obj,start,end)：查找指定元素在列表中第一次出现的位置，返回元素下标。
a = [1,2,3,4,5,6,7,8,9]
print(a.index(5)) #结果为4
a = [1,2,3,4,5,6,7,8,9]
print(a.index(6,0,8)) #结果为5
- 1
- 2
- 3
- 4
list.count()：查找指定元素在列表中出现的次数，返回数量值。
a = [1,2,3,4,5,6,7,8,9,5,7,5]
print(a.count(5)) #结果为3
- 1
- 2
使用成员运算符（in/not in）对列表内是否有此元素进行判断，返回True/False。
a = [1,2,3,4,5]
print(2 in a,2 not in a)
#结果为True False
- 1
- 2
- 3
5.列表排序
list.sort(reverse = True/False)：将列表中元素进行(降序/升序)排序（默认升序），不返回值。
a = [1,2,5,4,3]
a.sort()
print(a) #结果为[1, 2, 3, 4, 5]
a = [1,2,5,4,3]
a.sort(reverse=True)
print(a) #结果为[5, 4, 3, 2, 1]
- 1
- 2
- 3
- 4
- 5
- 6
sorted(list)：用法与sort基本一致，但是会生成一个新的列表对象，不对原列表进行更改。
a = [1,2,5,4,3]
b = sorted(a,reverse = True)
print(b) #结果为[5, 4, 3, 2, 1]
print(a) #结果为[1, 2, 5, 4, 3]
- 1
- 2
- 3
- 4
random.shuffle()：引入random随机库，随机打乱列表中元素排序。
import random
a = [1,2,3,4,5]
random.shuffle(a)
print(a) #结果为随机打乱的列表
- 1
- 2
- 3
- 4
list.reversed()：原地翻转列表中元素，生成一个新的一次性的可迭代对象。
一次性对象仅能使用一次
a = [1,2,3,4,5]
print(reversed(a)) #结果为<list_reverseiterator object at 0x000001F563314160>
print(list(reversed(a))) #结果为[5, 4, 3, 2, 1]
- 1
- 2
- 3
6.列表索引操作
list[num]：找到列表中指定位置的元素，多维列表就继续往下索引即可（list[num][num]）
a = [[1,[2,"杰尼龟"]],[3,4],[5]]
print(a[0][1]) #结果为[2, '杰尼龟']
- 1
- 2
7.列表切片操作
list[x:y:±step]：从编号x到编号y之前，从左到右或从右到左以step间隔取值
在切片操作中，起始终止编号不在[0:字符串长度-1]这个范围内也不会报错，超过0或末端按0和末端截取
8.其他操作
list.copy()：生成一个新的列表的浅拷贝对象。
import random
a = [1,2,3,4,5] ; b = a
random.shuffle(b)
print(a) #结果为随机打乱的列表
- 1
- 2
- 3
- 4
copy后修改列表2不会对列表1产生影响
import random
a = [1,2,3,4,5] ; b = a
b = a.copy()
random.shuffle(b)
print(a) #结果为[1, 2, 3, 4, 5]
- 1
- 2
- 3
- 4
- 5
多维列表：列表中嵌套列表（列表中可保存不限类型、不限数量的数据）
a = [[1,[2,"杰尼龟"]],[3,4],[5]]
print(a[0][1]) #结果为[2, '杰尼龟']
- 1
- 2
修改元素：列表是一种内置可变序列，可直接对列表中元素进行访问修改。
a = [1,2,3]
a[0] = 2
print(a) #结果为[2, 2, 3]
- 1
- 2
- 3
六、元组（tuple）
元组属于不可变序列，元组中没有增加元素、删除元素、修改元素等操作。其余操作与列表基本一致。
t =（‘holberton’，[1，2，3]）
元组t包含不同数据类型的元素，第一个元素是一个不可变的字符串，第二个元素是一个可变列表。元组本身不可变。即它没有任何改变其内容的方法。同样，字符串是不可变的，因为字符串没有任何可变方法。但是列表对象确实有可变方法，所以可以改变它。这是一个微妙的点，但是非常重要：不可变对象的“值” 不能改变，但它的组成对象是能做到改变的。
其实主要原因是元组内保存的是变量（也就是内存地址）。所以当变量指向对象发生变化时，如果导致变量发生变化（即不可变类型），此时元组保证该不可变类型不能修改。而如果当变量指向对象发生变化时，如果不会导致变量发生变化（即可变类型），此时元组中存储的该可变类型可以修改（因为变量本身并无变化）。
1.元组的创建与删除
通过圆括号创建（圆括号可省略）。
a = (10,20,"杰尼龟")
b = (10,)
c = 2,3,"可达鸭"
print(type(a),type(b),type(c),)
#结果为<class 'tuple'> <class 'tuple'> <class 'tuple'>
- 1
- 2
- 3
- 4
- 5
单元素括号也可省略，但是逗号不能省略，不然会被python识别为其他类型数据
a = (10,)
b = 10,
c = (10)
print(type(a),type(b),type(c),)
#结果为<class 'tuple'> <class 'tuple'> <class 'int'>
- 1
- 2
- 3
- 4
- 5
通过tuple()函数将可迭代数据转换为元组对象。
a = tuple([1,2,3,4])
b = tuple(range(5))
c = tuple("12345")
print(a) ; print(b) ; print(c)
#结果为(1, 2, 3, 4) ；(0, 1, 2, 3, 4) ；('1', '2', '3', '4', '5')
- 1
- 2
- 3
- 4
- 5
通过生成器推导式创建元组
通过生成器推导式，生成一个可迭代的一次性对象，再将此对象通过list()/tuple()方法转换为想要的列表和元组
a = (i for i in range(5))
print(a) #结果为<generator object <genexpr> at 0x0000025750B1ABA0>
print(tuple(a)) #结果为(0, 1, 2, 3, 4)
- 1
- 2
- 3
通过del 删除元组本身
a = (10,20,30)
del a
print(a) #NameError: name 'a' is not defined
- 1
- 2
- 3
2.相关操作
元组为python内置不可变序列对象，除列表中的添加、删除、修改等方法不可使用以外，其余操作基本一致。
元组可用操作：切片操作、索引操作、拼接操作、成员运算符、比较运算符、计数方法（len()、max()、min()、sum()）等
与列表操作不同之处
列表排序可用list.sort()方法，对列表本身进行排序，但元组不行。元组对象想要进行排序只能试用sorted(tuple)进行排序并生成一个新的列表对象，不对原对象进行修改。
a = (1,2,3,6,5,4)
b = sorted(a)
print(a) #结果为(1,2,3,6,5,4)
print(b) #结果为[1, 2, 3, 4, 5, 6]
- 1
- 2
- 3
- 4
zip()：通过zip方法将多个列表的指定元素组合成一个元组，并返回这个一次性的zip对象。
一次性对象仅能使用一次
a = [1,2,3]
b = [4,5,6]
c = [7,8,9]
d = zip(a,b,c)
print(d) #结果为<zip object at 0x0000028C7CA43900>
print(tuple(d)) #结果为((1, 4, 7), (2, 5, 8), (3, 6, 9))
print(list(d)) #结果为[]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
七、字典（dict）
含义
字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、替换、添加对应的“值对象”。
列表中我们通过下标找到对应的对象。字典中通过“键对象”找到对应的“值对象”。键是任意不可变的数据，如：字符串、元组、整数、浮点数。但是列表、字典、集合这些可变对象不能作为键。并且键不可重复。值可以是任意数据且可重复
1.字典的创建
通过花括号【{}】进行创建。
d = {"name":"杰尼龟","age":25,"job":"students"}
print(type(d)) #结果为<class 'dict'>
- 1
- 2
通过dict()创建。
dict()里面加入赋值运算进行创建
d = dict(name="杰尼龟",age = 18)
print(d) #结果为{'name': '杰尼龟', 'age': 18}
- 1
- 2
dict()括号里面加入特定列表【[(1,2)]类型】进行创建
d = dict([("name","杰尼龟"),("age",18)])
print(d) #结果为{'name': '杰尼龟', 'age': 18}
- 1
- 2
dict()括号里面加入zip()函数进行创建
a = ["name","age"]
b = ["杰尼龟",18]
d = dict(zip(a,b))
print(d) #结果为{'name': '杰尼龟', 'age': 18}
- 1
- 2
- 3
- 4
通过dict.fromkeys()方法创建值为None的字典
d = dict.fromkeys(["name","age","job"])
print(d) #结果为{'name': None, 'age': None, 'job': None}
- 1
- 2
2.字典值的访问
通过键访问对应的值，如不存在此键则抛出异常
d = {"name":"杰尼龟","age":18}
print(d["name"],d["age"]) #结果为杰尼龟 18
- 1
- 2
通过dict.get()方法使用键来进行值的获取，区别在于，不存在此键时会返回None，而不会报错。get方法也可在键不存在时指定返回的值。
d = {"name":"杰尼龟","age":18}
print(d.get("name")) #结果为杰尼龟
print(d.get("age")) #结果为18
print(d.get("job")) #结果为None
print(d.get("job","student")) #结果为student
print(d.get("age","student")) #结果为18
- 1
- 2
- 3
- 4
- 5
- 6
3.字典键值的访问
dict.keys()：列出所有的键。
d = {"name":"杰尼龟","age":18}
print(d.keys()) #结果为dict_keys(['name', 'age'])
- 1
- 2
dict.values()：列出所有的值。
d = {"name":"杰尼龟","age":18}
print(d.keys()) #结果为dict_keys(['name', 'age'])
- 1
- 2
len(dict)：查询字典的键值对的数量。
d = {"name":"杰尼龟","age":18}
print(len(d)) #结果为2
- 1
- 2
使用成员判断符（in/not in）判断键是否在字典内（仅判断键，不能判断值）。
d = {"name":"杰尼龟","age":18}
print("杰尼龟" in d) #结果为False
print("name" in d) #结果为True
- 1
- 2
- 3
4.字典键值对的添加
dict[key] = vlaue ：更新字典中键的值，如果没有此键则添加至字典末尾。
d = {"name":"杰尼龟","age":18}
d["name"] = "可达鸭"
d["color"] = "yellow"
print(d) #结果为{'name': '可达鸭', 'age': 18, 'color': 'yellow'}
- 1
- 2
- 3
- 4
dict1.update(dict2)：将字典2中的键值对添加到字典1中，如果key有重复则替换对应的值，如无重复，则添加到末尾。
d = {"name":"杰尼龟","age":18}
a = {"name":"可达鸭","color":"yellow"}
d.update(a)
print(d) #结果为{'name': '可达鸭', 'age': 18, 'color': 'yellow'}
- 1
- 2
- 3
- 4
5.字典中键值对的删除
del 删除字典本身或删除字典中指定的键。
a = {"name":"可达鸭","age":18,"color":"yellow"}
del a["color"]
print(a) #结果为{'name': '可达鸭', 'age': 18}
del a
print(a) #NameError: name 'a' is not defined
- 1
- 2
- 3
- 4
- 5
dict.clear()：清空字典内部所有键值对。
a = {"name":"可达鸭","age":18,"color":"yellow"}
a.clear()
print(a) #结果为{}
- 1
- 2
- 3
dict.pop()：删除字典内指定键，并将对应的值提取出来留作他用
a = {"name":"可达鸭","age":18,"color":"yellow"}
b = a.pop("color")
print(a) #结果为{'name': '可达鸭', 'age': 18}
print(b) #结果为yellow
- 1
- 2
- 3
- 4
dict.popitem：字典本身是无序可变序列，没有首位元素和尾位元素之说。popitem方法会随机返回并删除一个键值对。返回一个(key,value)形式，按照 LIFO（Last In First Out 后进先出法） 顺序规则，即最末尾的键值对。
a = {"name":"可达鸭","age":18,"color":"yellow",1:2,3:4,5:6}
b = a.popitem()
print(a) ; print(b)
#结果为{'name': '可达鸭', 'age': 18, 'color': 'yellow', 1: 2, 3: 4}、(5, 6)
b = a.popitem()
print(a) ; print(b)
#结果为{'name': '可达鸭', 'age': 18, 'color': 'yellow', 1: 2}、(3, 4)
b = a.popitem()
print(a) ; print(b)
#结果为{'name': '可达鸭', 'age': 18, 'color': 'yellow'}、(1, 2)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
5.字典使用小试
通过列表和字典来存储表格数据
d1 = {"name":"杰尼龟","age":18,"salary":8000,"city":"成都"}
d2 = {"name":"可达鸭","age":19,"salary":9000,"city":"上海"}
d3 = {"name":"皮卡丘","age":20,"salary":10000,"city":"北京"}
l = [d1,d2,d3]
for i in range(len(l)): print(l[i]["name"],l[i]["age"],l[i]["salary"],l[i]["city"])
- 1
- 2
- 3
- 4
- 5
- 6
八、集合（set）
集合是一种无序可变序列，集合的底层实现是字典，只不过只包含了字典的键。所以集合中的元素不能重复
1.集合的创建
使用花括号创建【{}】
```python
s = {1,2,3,"杰尼龟",True,False}
print(type(s)) #结果为set
- 1
- 2
- 3
使用set()将列表、元组等可迭代对象转换为集合，集合中元素不重复，所以有重复元素只保留一个。
l = [1,2,3,"杰尼龟"]
t = (10,20,30,"可达鸭")
s1 = set(l)
s2 = set(t)
print(s1) #结果为{1, 2, 3, '杰尼龟'}
print(s2) #结果为{'可达鸭', 10, 20, 30}
a = "杰尼龟"
s1 = set(a)
print(s1) #结果为{'尼', '龟', '杰'}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
2.添加集合中的元素
使用set.add()函数在集合中添加元素，重复元素不会添加
a ={10, 20 , 30}
a.add(40)
print(a) #结果为{40, 10, 20, 30}
- 1
- 2
- 3
3.删除集合中的元素
使用remove()函数删除指定元素
a ={10, 20 , 30}
a.remove(10)
print(a) #结果为{20, 30}
- 1
- 2
- 3
使用clear()函数清空集合中所有元素
a ={10, 20 , 30}
a.clear()
print(a) #结果为set()
- 1
- 2
- 3
使用del 删除集合本身，集合不支持使用del删除指定项
a ={10, 20 , 30}
del a
print(a) #结果为NameError: name 'a' is not defined
- 1
- 2
- 3
4.集合相关操作
并集将两个集合中重合部分保留一个，然后生成一个合并后的新集合对象。
a ={10, 20 , 30}
b = {30,40,50}
c = a | b
print(c) #结果为{50, 20, 40, 10, 30}
- 1
- 2
- 3
- 4
交集取出两个集合中重合部分，然后生成一个新的集合对象。
a ={10, 20 , 30}
b = {30,40,50}
c = a & b
print(c) #结果为{30}
- 1
- 2
- 3
- 4
差集去除集合1在集合2中也存在的元素，生成一个新的列表对象。
a ={10, 20 , 30}
b = {30,40,50}
c = a - b
d = b -a
print(c) #结果为{10, 20}
print(d) #结果为{40, 50}
- 1
- 2
- 3
- 4
- 5
- 6
九、分支语句
通过判断条件是否成立，来选择执行对应分支，选择结构有多种形式，分为：单分支、双分支、多分支，流程图如下：
单分支语句
双分支语句
多分支结构
1.条件表达式解释
在选择和循环语句中，条件表达式的值为false时不会执行，具体情况如下：
False、0、0.0、空值None、空的序列对象（空列表、空字符串、空元组、空字典、空集合）、空range对象、空迭代对象。
其余情况值均为true。
if 0 : print("值为假")
if [] : print("值为假")
if [1] : print("值为假")
- 1
- 2
- 3
- 4
- 5
- 6
注意：条件表达式中不能出现赋值语句【a=b】
1.单分支语句
if条件判断语句：
执行语句
a = int(input("请输入一个整数"))
if a < 10 : print("比十小")
- 1
- 2
- 3
①条件判断语句后面必须接冒号
②执行语句注意缩进
③执行语句可以是一条也可以是多条，多条缩进注意保持一致
2.双分支语句
if条件判断语句：
执行语句
else：
执行语句*
a = int(input("请输入一个整数："))
if a<=10: print(f"您输入的是{a}")
else: #表示与前面条件互斥 a>10 print("您输入的不在范围内")
- 1
- 2
- 3
- 4
- 5
三元条件运算符
在双分支条件判断中可使用print(条件为真时候的值 if （条件表达式） else 条件为假时候的值)来更加简洁的输出自己想要的结果。
a = int(input("请输入一个整数："))
print("输入的是一个偶数" if a%2==0 else "输入的是一个奇数")
- 1
- 2
3.多分支语句
if 条件表达式
执行语句
elif 条件表达式
执行语句
.
.
.
elif 条件表达式
执行语句
else:
执行语句
多分支语句有逻辑顺序，不可随意调换编写顺序，如下列实例，调换顺序后就不能用此写法
a = int(input("请输入你的分数："))
if 0<=a<=100: if a >=90 : # 等同于 90<=a<=100 print(f"您的分数是{a},评分为S") elif a >= 80: # 等同于 80<=a<90 print(f"您的分数是{a},评分为A") elif a >= 70: # 等同于 70<=a<=80 print(f"您的分数是{a},评分为B") elif a >= 60: # 等同于 60<=a<=70 print(f"您的分数是{a},评分为C") elif a < 60: print(f"您的分数是{a},评分为D")
else: print("输入有误")
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
4.条件判断嵌套
注意不同层级的缩进量
a = int(input("请输入你的分数："))
if 0<=a<=100: if a >=90 : # 等同于 90<=a<=100 print(f"您的分数是{a},评分为S") elif a >= 80: # 等同于 80<=a<90 print(f"您的分数是{a},评分为A") elif a >= 70: # 等同于 70<=a<=80 print(f"您的分数是{a},评分为B") elif a >= 60: # 等同于 60<=a<=70 print(f"您的分数是{a},评分为C") elif a < 60: print(f"您的分数是{a},评分为D")
else: print("输入有误")
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
十、循环语句
循环语句用来帮我们重复得执行多条语句，每次执行都会判断返回的结果是否为true，是则继续循环，不是则结束循环。
循环语句中至少应该包含用来改变判断条件的语句使循环终结，不然会变成死循环。
1.while 循环
while循环语句格式
while 条件判断
循环语句*
n = 0 ; l = []
while n <= 10: #条件判断，开始循环 n += 1 #控制条件判断结果 l.append(n)
print(l) #结果为[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
- 1
- 2
- 3
- 4
- 5
while 循环例题
打印1~100之间整数的累加和
n = 0 ; l = 0
while n <= 100: #条件判断，开始循环 l = l + n n += 1 #控制条件判断结果
print(l) #结果为5050
- 1
- 2
- 3
- 4
- 5
2.for循环
for循环通常用于可迭代对象的遍历，语法格式如下：
for 变量 in 可迭代对象:
循环语句
可迭代对象：①序列：元组、列表、字符串、②字典、③迭代器函数（iterator）、④生成器函数（generator）
遍历列表
for i in [1,2,3]: print(i) #结果为1 2 3
- 1
- 2
遍历元组
for i in （1,2,3）: print(i) #结果为1 2 3
- 1
- 2
遍历字符串
for i in "123": print(i) #结果为1 2 3
- 1
- 2
遍历字典
d = {"name":"杰尼龟","age":18,"color":"blue"}
for i in d: #遍历键 print(i) #结果为name age color
for i in d.values(): #遍历值 print(i) #结果为杰尼龟 18 blue
for i in d.items(): #遍历键值对 print(i) #结果为('name', '杰尼龟') ('age', 18) ('color', 'blue')
- 1
- 2
- 3
- 4
- 5
- 6
- 7
遍历range函数（range(start,end,step)）
for i in range(5): print(i) #结果为0 1 2 3 4
for i in range(1,5): print(i) #结果为 1 2 3 4
for i in range(-5,5,2): print(i) #结果为 -5 -3 -1 1 3
- 1
- 2
- 3
- 4
- 5
- 6
配合zip()函数进行并行遍历
a = ["杰尼龟","可达鸭","皮卡丘"]
b = [19,20,25,30]
for name,age in zip(a,b): print(f"{name}--{age}")
- 1
- 2
- 3
- 4
- 5
等同于以下写法，且循环次数由最短那个对象决定。
a = ["杰尼龟","可达鸭","皮卡丘"]
b = [19,20,25,30]
for i in range(3): print(f"{a[i]}--{b[i]}")
- 1
- 2
- 3
- 4
- 5
for循环练习
输出1~100之间的整数累加和
sum_all = 0
for i in range(101): sum_all =sum_all + i
print(sum_all)
- 1
- 2
- 3
- 4
输出1~100之间的奇数累加和
sum_all = 0
for i in range(101): if i%2 >0: sum_all =sum_all + i
print(sum_all)
- 1
- 2
- 3
- 4
- 5
for循环搭配推导式生成序列
相较于正常写法，推导式写法更为简洁
使用推导式生成列表[表达式 for 变量 in 可迭代对象 if 条件判断]
集合使用方法一致，只是外部为花括号{}
a = [x for x in range(5)]
print(a) #结果为[0, 1, 2, 3, 4]
b = [x*2 for x in range(5) if x%2==0]
print(b) #结果为[0, 4, 8]
b = [i for i in "杰尼龟"]
print(b) #结果为['杰', '尼', '龟']
- 1
- 2
- 3
- 4
- 5
- 6
for循环可以多个
b = [(i,j) for i in range(5) for j in range(3) if j >=1]
print(b) #结果为[(0, 1), (0, 2), (1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2), (4, 1), (4, 2)]
- 1
- 2
使用推导式创建字典
#普通写法(列出对象中每个元素出现的次数)
a= "hello python!"
b = {}
for i in a : b[i] = a.count(i)
print(b)
#推导式
a= "hello python!"
b = {i:a.count(i) for i in a}
print(b)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
使用推导式创建元组
元组也有推导式，使用圆括号创建，但是创建的是一个一次性的生成器对象。
a = (i for i in "杰尼龟")
print(a) #结果为<generator object <genexpr> at 0x000002B0A8B3FBA0>
b = tuple(a)
print(b) #结果为('杰', '尼', '龟')
c = tuple(a)
print(c) #结果为()
- 1
- 2
- 3
- 4
- 5
- 6
3.嵌套循环
一个循环体内可加入其他循环体
循环条件判断:
循环语句
循环条件判断:
循环语句
使用实例
for i in range(5): for j in range(5): print(i,end="\t") print()
'''结果为
0 0 0 0 0
1 1 1 1 1
2 2 2 2 2
3 3 3 3 3
4 4 4 4 4
'''
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
打印九九乘法表
for i in range(1,10): for j in range(1,i+1): print(f"{i}*{j}={i*j}",end=" ") print()
'''结果为
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
'''
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
使用列表+字典储存表格，再打印工资高于15000的员工信息
d1 = {"name":"杰尼龟","age":18,"salary":10000,"city":"成都"}
d2 = {"name":"皮卡丘","age":20,"salary":20000,"city":"上海"}
d3 = {"name":"小火龙","age":25,"salary":30000,"city":"北京"}
l = [d1,d2,d3]
for i in l: if i.get("salary") >= 15000: print(i)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
4.break语句
结束整个循环，嵌套循环时结束最近层级的循环。
while True: a = input("请输入一个0~10数字之间的数字：") if int(a) == 8: break for i in range(5): for j in range(5): if i*j >= 6: break print(i, j) print()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
5.continue语句
执行到该语句时跳过本次循环，余下语句不执行，直接开始下一轮循环。嵌套循环时跳过最近层级的循环。
for i in range(5): if i == 3: continue print(i) #结果为0，1，2，4
for i in range(3): for j in range(3): if j == 2: continue print(i,j)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
6.else:语句
while循环和for循环可再后面接一个else语句（可选），如果循环没有被break语句中断，那么再循环完以后就会执行else，否则不会执行。
循环条件判断:
循环语句
else:
执行语句
7.循环语句代码优化
①局部变量查询快，优先选择局部变量
②尽量减少循环中的计算次数
③嵌套循环中，尽量减少内部循环的计算次数，能往外提的全放外部
④列表元素添加删除优先选择在尾部进行操作
⑤字符串拼接采用join()
测试
import time
a = time.time()
for i in range(1000): l = [] for j in range(10000): l.append(i*100+j*1000)
b = time.time()
print(b-a) #结果为1.49
a = time.time()
for i in range(1000): l = [] c = i*100 for j in range(10000): l.append(c+j*1000)
b = time.time()
print(b-a) #结果为1.19
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
运行效果一致时，下半运行速度优于上半，数值越大差异越明显
十一、函数
函数本质上就是代码块。函数不仅能实现代码的复用，更能使代码产生一致性（修改函数，后续所有使用的地方都会跟着改变）
| 类型 | 作用 |
|---|---|
| 内置函数 | 如print()、input()等python内部已建好的函数，使用时直接输入名称调用即可 |
| 标准库 | python官方的库，使用import导入库，即可调用其中建好的函数 |
| 第三方库 | 通过下载安装他人建好的库，之后操作方法与标准库一致 |
| 自定义函数 | 在用户编写代码的过程中，根据自身需求创建函数进行使用，用来实现代码的复用 |
1.函数的定义和调用
定义
def+空格+函数名+圆括号+冒号
函数语句
def say_hi():
name = input("请输入您的姓名：")
print(f"{name},你好！")
- 1
- 2
- 3
调用
定义完成后，与内置函数使用方法一致
def say_hi():
name = input("请输入您的姓名：")
print(f"{name},你好！")
say_hi()
- 1
- 2
- 3
- 4
- 5
2.形参与实参（参数的传递详见扩充部分）
形参：即形式参数，定义函数时设置的参数
实参：即实际参数，调用函数时填入的参数
def print_circle(n): print("⭕"*n)
print_circle(3)
def num(a,b):
if a>b:
print(a,"是较大值")
else:
print(b,"是较大值")
num(10,20)
num(30,20)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
要点：
①括号内形参列表，多个参数使用逗号隔开
②括号内没有参数也要保留括号
③形参和实参必须一一对应
3.函数的注释
函数创建语句
‘’‘注释语句’‘’
函数语句
def num(a,b):
'''用来比较两个数的大小，并打印最大值'''
if a>b:
print(a,"是较大值")
else:
print(b,"是较大值")
num(10,20)
num(30,20)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
注释的调用
help(函数名._doc_)
def num(a,b):
'''用来比较两个数的大小，并打印最大值'''
if a>b:
print(a,"是较大值")
else:
print(b,"是较大值")
num(10,20)
num(30,20)
print(help(num.__doc__))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
4.函数返回值
return返回值
①如果函数中有return语句则返回该语句所指向的值，并结束函数，不执行余下函数。
def num(a,b): c = (a+b)/2 return c print("杰尼龟") print(num(20,40))
- 1
- 2
- 3
- 4
- 5
- 6
②如果函数中没有return语句则返回None。
def num(a,b): c = (a+b)/2 print("杰尼龟")
print(num(20,40))
def num(a,b): c = (a+b)/2 return print("杰尼龟") print(num(20,40))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
③如果需要返回多个值使用列表、元组、字典、集合等多个值存起来。
def triangle(a,b,c): return[a**2,b**2,c**2]
print(triangle(3,4,5))
- 1
- 2
- 3
- 4
5.函数运行逻辑
def name():
print("杰尼龟")
name()
a = name
a()
- 1
- 2
- 3
- 4
- 5
- 6
当我们使用def进行函数创建时，电脑会在内存中创建一个【print(“杰尼龟”)】的函数对象并通过变量【name】对其进行引用，所以后续使用时可以使用【a = name】来使变量【a】也能调用函数。
十二、类的创建与使用
1.面向过程与面向对象
面向过程
面向过程主要是注重于程序的运行逻辑。在遇到一些小项目时，我们去思考怎么让程序按步骤的去完成此项目，再将这些步骤转换为实质性的代码，这就是面向过程的编程方式。
例如：如何启动一台电脑
①连接电源
②按开机键
③输入密码
面向对象
python中一切皆对象（数据类型、序列、函数、类等皆为对象），在面向对象的编程中我们更注重各个对象之间的逻辑关系。在大型项目中我们首先去思考项目是由哪些对象组成的，再分别创造出所需要的各个对象，最后再组装到一起形成一个完整的项目。
例如：如何造一台电脑
①设计电脑的组成部分
②创造对应零件（对象）：操作系统、显卡、内存、硬盘、主板、CPU、电源、机箱等
③组装各部分零件
④亮机测试
宏观上由面向对象把握，微观上还是面向过程进行执行。
2.类的定义
类的创建办法（类名要满足标识符规则，通常采用驼峰原则，多个单词首字母均大写，用下划线连接）
class 类名
类体
类体中我们可以定义属性和方法（即函数）。
属性用来描述数据，方法就是属性的相关操作函数。
class Students: #首字母大写，多个单词采用驼峰原则 def __init__(self, name, color): #构造函数第一个实例必须为self self.name = name #self.name：实例属性，name：形参 self.color = color def check_results(self): #实例方法 print(f"{self.name}的颜色是{self.color}")
s01 = Students("杰尼龟", "blue") #自动调用构造函数
s01.check_results() #调用实例相关操作函数
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
3.构造方法
构造方法__init__()：我们在创建对象时，需要使用构造方法__init__()对实例对象进行属性的初始化，即对象创建后初始化其属性（将其赋值给变量），无返回值。
构造函数使用
①名称固定为__init__()，缺一不可（下划线为英文状态下左右各两个）
②方法中第一个实例必须为self，名称可变，但按照一般惯例均使用self
③构造方法通常用来对实例属性进行初始化（赋值），比如：
def __init__(self, name, color): #self:实例对象形参，name:形参，color：形参 self.name = name #self.name：实例属性，name：初始值 self.color = color
- 1
- 2
- 3
④通过【类名(参数列表)】来调用构造函数__init__()。将创建好的对象赋值给对应的变量。比如：
s01 = Students("杰尼龟", "blue") #调用构造函数
- 1
⑤__init__()：对创建好的对象进行初始化，即赋值。
⑥__new__()：用于创建新对象，我们一般无需重定义该方法。
4.实例属性
实例属性时从属于实例对象的属性，也称为实例变量（self.实例属性名）
实例属性使用
①实例属性一般在__init__()方法中进行定义。
class 类名:
def init(self,形参1，形参2):
self.实例属性名 = 形参1
self.实例属性名 = 形参2
②在本类的其他实例方法中，也是通过self进行调用。
class 类名:
def init(self,形参1，形参2):
self.实例属性名 = 形参1
self.实例属性名 = 形参2
def 实例方法名（函数名）:
self.实例属性名+相关操作
③创建实例对象后使用实例对象进行调用。
实例对象名 = 类名(实参1，实参2)
实例对象名.实例方法名（函数）
实例对象名.实例属性名 = 值 #给实例属性更改值，或者新增属性
class Students: def __init__(self, name, color): #构造函数第一个实例必须为self self.name = name #实例属性 self.color = color def check_results(self): #实例方法 print(f"{self.name}的颜色是{self.color},年龄是{self.age}")
s01 = Students("杰尼龟", "blue") #自动调用构造函数
s01.age = 18
s01.check_results() #调用实例相关操作函数
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
5.实例方法
实例方法从属于实力对象，本质上也是实例属性。
实例方法的创建
def 实例方法名(self,形参1，形参2):
函数体
def check_results(self): #实例方法 print(f"{self.name}的颜色是{self.color},年龄是{self.age}")
- 1
- 2
实例方法的调用
实例名.实例方法名(形参1，形参2)
s01.check_results() #调用实例相关操作函数
- 1
①创建实例方法时，第一个参数必须为实例参数，按惯例使用self。
②调用实例方法无需也不能给实例参数传参，应由解释器自动传入参数。
实例对象的判断
isinstance()：判断实例是否在类之中，返回True、False。
class Students: pass
class Num: pass
s01 = Students()
s02 = Num()
print(isinstance(s01,Students))
print(isinstance(s02,Students))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
实例方法与函数的区别
实例方法从属于特定的实例对象，调用必须通过实例对象进行调用，而普通函数没有此要求。本质上两者都是用来完成对应功能的语句块，没有区别。
6.类对象
python中一切皆对象，类在定义时（class 类名：），解释器会自动创建一个类对象。
class Students: pass
print(id(Students))
print(type(Students))
s01 = Students
s = s01()
print(s)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
当执行class Students时，解释器创建了一个类的对象，并将对象的id指向了students这个变量，所以后面我们可以使用s01 = Students来让s01也指向这个对象。
7.类属性
类属性从属于类对象，也称为类变量，可以被所有的实例的对象共享，定义方法如下：
class 类名：
变量名 = 初始值
class Students: classes = "6班" grade = "4年级" def __init__(self,name,score): self.score = score self.name = name def check_results(self): print(f"{self.grade}{self.classes}{self.name}同学的成绩是{self.score}")
#可直接使用self对类变量进行调用
lilei = Students("李磊",98)
lilei.check_results()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
也可进行下列调用
class Students: classes = "6班" grade = "4年级" def __init__(self,name,score): self.score = score self.name = name def check_results(self): print(f"{Students.grade}{Students.classes}{self.name}同学的成绩是{self.score}")
lilei = Students("李磊",98)
hanmeimei = Students("韩梅梅",95)
lilei.check_results()
hanmeimei.check_results()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
内存示意图
8.类方法、静态方法
类方法
类方法从属于类对象，类方法一般通过装饰器（@classmethod）进行定义，可以使用类对象和实例对象进行调用
class Students: classes = "6班" grade = "4年级" def __init__(self,name,score): self.name = name self.score = score def check_results(self): print(f"{self.name}的成绩是{self.score}分") @classmethod def print_infor(cls): print(f"我们是{Students.grade}{Students.classes}")
lilei = Students("李磊",98)
Students.print_infor()
lilei.print_infor()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
要点：
①类方法中第一个参数必须为【cls】，表示类对象本身。
②在调用类方法时无需也不能给cls传入参数
③@classmethoed必须位于方法的上面一行
④类方法中访问实例属性、实例方法会报错
静态方法（转载于博客园）
静态方法是类中的函数，不需要实例。静态方法主要是用来存放逻辑性的代码，逻辑上属于类，但是和类本身没有关系，也就是说在静态方法中，不会涉及到类中的属性和方法的操作。 可以理解为，静态方法是个独立的、单纯的函数，它仅仅托管于某个类的名称空间中，便于使用和维护。
譬如，我想定义一个关于时间操作的类，其中有一个获取当前时间的函数。
import time
class TimeTest(object): def __init__(self, hour, minute, second): self.hour = hour self.minute = minute self.second = second @staticmethod def showTime(): return time.strftime("%H:%M:%S", time.localtime())
print(TimeTest.showTime())
t = TimeTest(2, 10, 10)
nowTime = t.showTime()
print(nowTime)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
如上，使用了静态方法（函数），然而方法体中并没使用（也不能使用）类或实例的属性（或方法）。若要获得当前时间的字符串时，并不一定需要实例化对象，此时对于静态方法而言，所在类更像是一种名称空间。
9.类方法、实例方法、静态方法的区别
实例方法：只能由实例对象进行调用，类对象无法调用。
类方法：实例对象和类对象均可调用
静态方法：实例对象和类对象均可调用，静态方法仅托管于类中，和类本身没有关系。
十三、花里胡哨的扩充(遇到什么写什么)
1.变量的作用域
变量起作用的范围称为变量的作用域。即全局变量与局部变量，不同作用域内同名变量不相互影响。
a = 3 #全局变量
def num():
b = 4 #局部变量
print(b)
print(a)
num()
- 1
- 2
- 3
- 4
- 5
- 6
全局变量
①当全局变量与局部变量同名时，则在函数内隐藏全局变量，只使用局部变量。
a = 3
def num():
print(a)
print(a)
num()
a = 3 #全局变量
def num():
a = 4 #局部变量
print(a)
num()
print(a)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
②想在函数内更改全局变量，需在函数内使用global进行声明。
a = 3 #全局变量
def num():
global a
a = 4 #局部变量
num()
print(a)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
2.参数的传递
参数的传递本质上就是实参到形参的传递。python中一切皆对象，所有赋值操作都是”引用“，所以参数的传递都是”引用传递“。参数的传递分为两类：可变对象的传递、不可变对象的传递。
可变对象的传递：列表、字典、集合、自定义的对象等。可变对象的传递直接作用于对象本身。
l = [1,2]
print(id(l))
print(l)
def add(a): a.append(3) print(id(a)) print(a)
add(l)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
不可变对象的传递：数字、字符串、元组、function等。不可变对象的传递会产生一个新的对象空间并使用新的值进行对象填充。
a = 1
print(id(a))
def sum(m): print(id(m)) n = m+2 print(id(n)) print(n)
sum(a)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
文章来源: blog.csdn.net，作者：你是个什么龟，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/qq_54704292/article/details/113468019