本文介绍了Python的基础知识，包括动态类型的变量、字符串的多种表示和操作、数字类型（整数、浮点数、复数）及其运算，以及布尔类型的逻辑运算。深入讲解了列表和元组的创建、访问、切片、查找、修改和转换，还涉及了循环、条件分支和列表推导式等控制结构。
一、基础铺垫
1、变量
- Python中，变量类型是动态的，无需在变量声明时显式指定变量的类型。
x = 10 # 整数类型
y = "Hello" # 字符串类型
z = [1, 2, 3] # 列表类型
- Python是一种强类型语言，但它具有类型推断的能力，可以根据赋值语句自动推导变量的类型。使用
type()函数可以检查变量的类型。
x = 10 # 整数类型
y = "Hello" # 字符串类型
z = [1, 2, 3] # 列表类型
print(type(x)) # 输出：<class 'int'>
print(type(y)) # 输出：<class 'str'>
print(type(z)) # 输出：<class 'list'>
- 变量名可以包括字母、数字、下划线，但变量名不能以数字开头，字母区分大小写。
- Python3支持中文。
商宗鑫 = "商宗鑫001"
print(商宗鑫)
补充
- python中一切的传递都是引用（地址），无论是赋值还是函数调用，不存在值传递。
- 可变对象和不可变对象
python变量保存的是对象的引用，这个引用指向堆内存里的对象，在堆中分配的对象分为两类，一类是可变对象，一类是不可变对象。 - 不可变对象（变量指向的内存的中的值不能够被改变）
当更改该对象时，由于所指向的内存中的值不可改变，所以会把原来的值复制到新的空间，然后变量指向这个新的地址。
python中数值类型（int和float），布尔型bool，字符串str，元组tuple都是不可变对象。
a = 1
print id(a) # 40133000L，整数1放在了地址为40133000L的内存中，a变量指向这个地址。
a += 1
print id(a) # 40132976L，整数int不可改变，开辟新空间存放加1后的int，a指向这个新空间。
- 可变对象（变量指向的内存的中的值能够被改变）
当更改该对象时，所指向的内存中的值直接改变，没有发生复制行为。
python中列表list，字典dict，集合set都是可变对象。包括自定义的类对象也是可变对象。
a = [1,2,3]
print id(a) # 44186120L。
a += [4,5] # 相当于调用了a.extend([4,5])
print id(a) # 44186120L，列表list可改变，直接改变指向的内存中的值，没开辟新空间。
a = a + [7,8] # 直接+和+=并不等价，使用+来操作list时，得到的是新的list，不指向原空间。
print id(a) # 44210632L
def f(default_arg=[]):
default_arg.append('huihui')
f() # ['huihui']
f() # ['huihui', 'huihui'] # 函数默认的可变参数并不会每次重新初始化，而是使用上次的作为默认值。
f([]) # ['huihui'] # 自行传入参数即可
2、字符串类型
- 字符串使用单引号，双引号，三引号
# 单引号
str = '商宗鑫002'
print(str) # 商宗鑫002
# 双引号
str_1 = "商宗鑫003"
print(str_1) # 商宗鑫003
# 单双引号搭配使用
str_2 = '"商宗鑫004"'
print(str_2) # "商宗鑫004"
- 字符串加法【拼接】和乘法【拷贝】
print(('大聪明'+'大傻子\n')*10)
# 加号 + 可以实现不同字符串拼接的功能，乘法可以重复拼接字符串。
- 转义字符
| 转义字符 | 描述 |
|---|---|
\\ | 反斜杠 |
\' | 单引号 |
\" | 双引号 |
\n | 换行 |
\t | 水平制表符 |
\r | 回车 |
\b | 退格 |
\f | 换页 |
\v | 垂直制表符 |
\ooo | 八进制数替代字符 |
\xhh | 十六进制数替代字符 |
\N{unicode_name} | 命名Unicode字符 |
\uxxxx | 十六进制数的Unicode字符 |
\Uxxxxxxxx | 32位十六进制数的Unicode字符 |
# 转义字符的使用
str_3 = '\"let\'s go!\"'
print(str_3)
str_4 = "I love python.\n我爱Python。"
print(str_4)
# 反斜杠\可以告诉Python字符串换行时并没有结束【不方便】，如果不加 \ 会报错。后面会介绍长字符串。
print("*****************\
***\
*") # *********************
2.1、原始字符串
print("D:\three\two\one")
# hree wo\one
# 没有达到预期效果，因为其中含有转义字符，\t--tab
# 转义字符
print("D:\\three\\two\\one")
# D:\three\two\one
# 原始字符串用r加字符串
print(r"D:\three\two\one")
2.2、长字符串
# 长字符串--三引号，可以代替反斜杠 \ 的使用
print('''
从明天起，做一个幸福的人
喂马，劈柴，周游世界
从明天起，关心粮食和蔬菜
我有一所房子，面朝大海，春暖花开
从明天起，和每一个亲人通信
告诉他们我的幸福
那幸福的闪电告诉我的
我将告诉每一个人
给每一条河每一座山取一个温暖的名字
陌生人，我也为你祝福
愿你有一个灿烂的前程
愿你有情人终成眷属
愿你在尘世获得幸福
我只愿面朝大海，春暖花开
''') # 原样输出
3、数字类型
import decimal
# 整数
# Python的整数长度不受限制，有无限大的精度
print(11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 +
111111111111111111111111111111111111111111111111111111111111)
# 浮点数
# Python采用IEEE754的标准来存储浮点数，会产生精度上的误差
print(0.1+0.2) # 0.30000000000000004
# decimal 是 Python 的一个内置模块，用于执行精确的十进制数计算。
# 它提供了一种精确地处理浮点数运算的方式，避免了浮点数舍入误差所带来的问题。
a = decimal.Decimal('0.1')
b = decimal.Decimal('0.2')
print(a+b) # 0.3
# 科学计数法
print(0.000005) # 5e-06
# 复数（实部和虚部）
a = 5+9j
print("实部 = ", a.real)
print("虚部 = ", a.imag)
# 实部 = 5.0
# 虚部 = 9.0
3.1、数字运算
# + , - , * , / 不再赘述
# // -- 地板除(商向下取整)
print(3//2) # 1
print(-3//2) # -2
# % -- 取模
print(3 % 2)
# divmod(a,b) --> 返回 (a//b,a%b)
print(divmod(5, 3)) # (1, 2)
# abs(a) -- 绝对值 a
print(abs(-56)) # 56
print(abs(1+5j)) # 5.0990195135927845 复数的模
# int() 强制转换为整数
print(type('857')) # <class 'str'>
print(type(int('857'))) # <class 'int'>
# print(int('3.14')) 报错，不能转换！！！
print(int(3.14)) # 3
print(int(3.99)) # 3 直接取整数部分，不是四舍五入
# float() 强制转换为浮点数
print(float('3.14')) # 3.14
print(float(52)) # 52.0
# complex() 强制转换为复数
print(complex('2+3j')) # (2+3j)
# print(complex('2 + 3j')) 报错！转复数时不能有空格
# 次方计算
print(pow(2, 3)) # 2^3 = 8
print(2**3) # 2^3 = 8
print(pow(2, 3, 2)) # 2^3 % 2 = 0
4、布尔类型
-
bool 非 0 即真
-
值为false的情况
- false的对象 None、False
- 值为 0 的数字类型 0、0.0、0j、Decimal(0)、Fraction(0,1)【表示分子为 0 ，分母为 1 的有理数】
- 空序列和集合 ‘’、()、{}、set()、range(0)
from fractions import Fraction
print(bool(' ')) # True
print(bool('')) # False
print(bool(1452)) # True
print(bool(Fraction(0, 1))) # False
- bool 类型就是特殊的整型，True 相当于 1 ，False相当于 0
print('123 == True : ', 123 == True) # False
print('1 == True : ', 1 == True) # True
print('0 == False : ', 0 == False) # True
print('"" == False : ', "" == False) # False
5、条件分支
- if - elif - else
x = 10
if x < 5:
print('x =', x, ', x < 5')
elif x < 50:
print('x =', x, ', x < 50') # x = 10 , x < 50
elif x < 80:
print('x =', x, ', x < 80')
else:
print('x =', x)
- 三元表达式
print('if 条件为真。') if 5 > 1 else print("if 条件为假。") # if 条件为真。
# 取较小的数
a = 3
b = 5
c = b if b < a else a
print('c =', c) # c = 3
# 分数评等级
score = 90
level = ('SSS' if score >= 95 else
'A+' if score >= 85 else
'A' if score >= 80 else
'B+' if score >= 70 else
'B' if score >= 60 else
'C+' if score >= 50 else 'C')
print(score, '分所在的等级为：', level) # 90 分所在的等级为： A+
- 分支结构嵌套
x = 11
if x > 4:
print('x > 4') # x > 4
if x > 10:
print('x > 10') # x > 10
else:
print('x <= 4')
if x <= 3:
print('x <= 3')
6、初识循环
while循环
# 计算从 1 累加到 1000
i = 1
sum = 0
while i <= 1000:
sum += i
i += 1
print(sum) # 500500
for循环
# 计算从 1 累加到 1000
sum = 0
for i in range(1001):
sum += i
print(sum) # 500500
# for 变量 in 可迭代对象:
for each in "商宗鑫":
print(each, end="-")
print()
# 商-宗-鑫-
- 循环嵌套
# 打印乘法口诀表
i = 1 # 列
j = 1 # 行
while j <= 9:
while i <= 9:
print(i, '*', j, '=', i*j, end=" ")
i += 1
if i > j:
i = 1
break
print()
j += 1
# 1 * 1 = 1
# 1 * 2 = 2 2 * 2 = 4
# 1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
# 1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
# 1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
# 1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
# 1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
# 1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
# 1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
break语句
i = 1
sum = 0
while i <= 1000:
sum += i
if sum > 1000:
break
i += 1
print(sum) # 1035
continue语句
i = 0
while i < 10:
i += 1
if i % 2 != 0:
continue
print(i)
# 2
# 4
# 6
# 8
# 10
==注意：==break 与 continue 每次只作用一层循环
else语句
i = 0
while i < 5:
print('正在循环...')
i += 1
else:
print('循环结束。')
# 正在循环...
# 正在循环...
# 正在循环...
# 正在循环...
# 正在循环...
# 循环结束。
for i in range(3):
print(i)
else:
print("else")
# 0
# 1
# 2
# else
==注意：==else 语句 当循环条件为假时才执行【循环正常结束才执行】
# 使用 break 语句跳出循环，不会触发 else 语句
i = 0
while i < 5:
print('正在循环...')
i += 1
if i == 2:
break
else:
print('循环结束。')
# 正在循环...
# 正在循环...
补充
len()用于获取一个对象的长度end()可以改变print()输出的结尾
i = 0
while i < len("商宗鑫"):
print("商宗鑫"[i], end="-")
i += 1
print()
# 商-宗-鑫-
range()生成数字序列，参数都为整型
# range(stop) [0,stop)
range(10) # 0 1 2 3 4 5 6 7 8 9
# range(start,stop) [start,stop)
range(1, 10) # 1 2 3 4 5 6 7 8 9
# range(start,stop,step) [start,stop) 指定步幅
range(1, 10, 2) # 1 3 5 7 9
range(10, 1, -2) # 10 8 6 4 2
# 计算从 1 累加到 1000
sum = 0
for i in range(1001):
sum += i
print(sum) # 500500
# 输出10以内所有的素数
for i in range(2, 10):
for j in range(2, i):
if i % j == 0:
break
else:
print(i, "是一个素数。")
# 2 是一个素数。
# 3 是一个素数。
# 5 是一个素数。
# 7 是一个素数。
补充：
random以当前系统时间作为随机种子，可以使用random.getstate()获取系统状态，使用random.setstate()恢复系统状态，重现随机数生成时的系统内部状态，进而重现随机数。random.random()：生成一个范围在 [0, 1) 的随机浮点数。random.randint(a, b)：生成一个范围在整数a和b（包括a和b）之间的随机整数。random.choice(seq)：从给定的序列seq中随机选择一个元素。random.shuffle(seq)：随机打乱给定序列seq中的元素顺序。random.sample(population, k)：从给定的总体population中选择k个不重复的随机元素。
import random # 伪随机数的标准库
temp = int(input("输入一个你猜的数据："))
guess = random.randint(0, 101)
while temp != guess:
if temp > guess:
print("猜大了哦。")
else:
print("猜小了哦。")
temp = int(input("输入一个你猜的数据："))
# temp_1 = input("输入一个你猜的数据：")
# 如果不强制转换的话将会一直死循环，因为数据类型不同
# print("temp_1的类型：", type(temp_1), "\ntemp的类型：", type(temp))
'''
temp_1的类型： <class 'str'>
temp的类型： <class 'int'>
'''
print("恭喜你猜对啦！")
7、逻辑运算符
# and【与】、or【或】、not【非】
print(True and False) # False
print(True and True) # True
print(False and False) # False
print('----------------------------')
print(True or False) # True
print(True or True) # True
print(False or False) # False
print('----------------------------')
print(not True) # False
print(not False) # True
# 逻辑运算符存在短路运算
print(4 and 5) # 5
print(0 and 5) # 0
print(0 or 5) # 5
print(5 or 0) # 5
8、类型转换，获取类型信息
type()可以获取变量的类型。isinstance()可以判断两个变量类型是否相同。
a = "商宗鑫"
isinstance(a, str) # True
isinstance(520, float) # False
isinstance(520, int) # True
# int() 强制转换为整数
print(type('857')) # <class 'str'>
print(type(int('857'))) # <class 'int'>
# print(int('3.14')) 报错，不能转换！！！
print(int(3.14)) # 3
print(int(3.99)) # 3 直接取整数部分，不是四舍五入
# float() 强制转换为浮点数
print(float('3.14')) # 3.14
print(float(52)) # 52.0
# complex() 强制转换为复数
print(complex('2+3j')) # (2+3j)
# print(complex('2 + 3j')) 报错！转复数时不能有空格
9、运算符优先级
| 序号 | 运算符 | 描述 |
|---|---|---|
| 1 | () | 括号 |
| 2 | **、^ | 幂运算 |
| 3 | +, -, ~ | 一元运算符 |
| 4 | *, /, %, // | 乘法、除法、取模和取整除 |
| 5 | +, - | 加法和减法 |
| 6 | <<, >> | 位移运算符 |
| 7 | &, |, ^ | 位运算符 |
| 8 | <, >, <=, >=, ==, != | 比较运算符 |
| 9 | is, is not | 身份运算符 |
| 10 | in, not in | 成员运算符 |
| 11 | not | 逻辑运算符（非） |
| 12 | and | 逻辑运算符（与） |
| 13 | or | 逻辑运算符（或） |
| 14 | x if condition else y | 三元条件运算符 |
| 15 | [] | 索引运算符 |
| 16 | [:] | 切片运算符 |
| 17 | =, +=, -=, *=, /=, %=, //=, **=, <<=, >>=, &=, |=, ^= | 赋值运算符 |
| 18 | () | 调用运算符 |
| 19 | . | 成员访问运算符 |
| 20 | lambda | Lambda表达式 |
==注意：==表格中的序号仅用于表示运算符的相对优先级，序号越小表示优先级越高。
二、进阶知识
1、列表
- 创建列表
arr = [1, 2, 3, 5, 4]
print(arr)
- 列表是一种序列，可以用循环遍历
arr = [1, 2, 3, 5, 4]
for each in arr:
print(each)
-
列表可以通过下标访问具体元素
-
可以用 len() 获取列表长度
arr = [1, 2, 3, 5, 4]
i = 0
while i < len(arr):
print(arr[i])
i += 1
- 当下标为负数时会从列表最后一个元素开始往前数
arr = [1, 2, 3, 5, 4]
print(arr[-1]) # 4
1.1、列表切片
# [start:stop:step] [start:stop)
arr = [1, 2, 3, 5, 4]
print(arr[0:3]) # [1, 2, 3]
print(arr[:3]) # [1, 2, 3]
print(arr[3:5]) # [5, 4]
print(arr[3:]) # [5, 4]
# 调整步幅为 2
print(arr[::2]) # [1, 3, 4]
# 倒序输出
print(arr[::-1]) # [4, 5, 3, 2, 1]
1.2、添加元素
.append(待插入元素)尾加一个元素
heros = []
heros.append(1)
print(heros) # [1]
.extend(可迭代对象)尾加一个可迭代对象
heros.extend(["商宗鑫", 4, 3, 4, 5, 6, 7])
print(heros) # [1, '商宗鑫', 4, 3, 4, 5, 6, 7]
- 利用切片
heros[len(heros):] = ["张爱玲", "乔治", "佩琪"]
print(heros) # [1, '商宗鑫', 4, 3, 4, 5, 6, 7, '张爱玲', '乔治', '佩琪']
heros[4:4] = ["001"]
print(heros) # [1, '商宗鑫', 4, 3, '001', 4, 5, 6, 7, '张爱玲', '乔治', '佩琪']
heros[0:0] = ["002"]
print(heros) # ['002', 1, '商宗鑫', 4, 3, '001', 4, 5, 6, 7, '张爱玲', '乔治', '佩琪']
.insert(插入位置,插入元素)任意位置插入元素
heros.insert(0, 1000)
print(heros)
# [1000, '002', 1, '商宗鑫', 4, 3, '001', 4, 5, 6, 7, '张爱玲', '乔治', '佩琪']
1.3、删除元素
.remove(待删除元素)删除指定元素
如果列表中存在多个匹配元素，remove()只会删除第一个
如果指定的元素不存在程序会报错
heros.remove("商宗鑫")
print(heros) # [1000, '002', 1, 4, 3, '001', 4, 5, 6, 7, '张爱玲', '乔治', '佩琪']
.pop(索引)删除某个索引值对应的元素
heros.pop(1)
print(heros) # [1000, 1, 4, 3, '001', 4, 5, 6, 7, '张爱玲', '乔治', '佩琪']
.clear()清空列表
heros.clear()
print(heros) # []
1.4、修改元素
- 利用索引可修改单个元素
heros[5] = "商宗鑫"
print(heros) # [0, 1, 2, 3, 4, '商宗鑫', 6, 7, 8, 9]
- 利用切片可以连续修改元素
heros[1:6] = ["张爱玲", "罗贯中"]
print(heros) # [0, '张爱玲', '罗贯中', 6, 7, 8, 9]
- 排序
heros.sort() # 从小到大排序
print(heros) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
heros.sort(reverse=True) #从大到小排序
print(heros) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
- 反转
heros.reverse()
print(heros) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1.5、查看元素
.count(元素,[start],[end])指定区间查找元素个数，区间可省略
heros.append(1)
print(heros) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1]
print(heros.count(1)) # 2
.index(元素)查找元素第一次出现的索引值
print(heros.index(1)) # 8
# 替换元素
heros[heros.index(1)] = "商宗鑫"
print(heros) # [9, 8, 7, 6, 5, 4, 3, 2, '商宗鑫', 0, 1]
.copy()拷贝列表
h = heros.copy()
print(h) # [9, 8, 7, 6, 5, 4, 3, 2, '商宗鑫', 0, 1]
- 利用切片实现拷贝
h1 = heros[:]
print(h1) # [9, 8, 7, 6, 5, 4, 3, 2, '商宗鑫', 0, 1]
+拼接
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9]
list = list1 + list2
print(list) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
*重复拼接【拷贝】
list = list1*2
print(list) # [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
1.6、嵌套列表
- 创建嵌套列表
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
print(matrix) # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
- 利用
for循环初始化列表
A = [0]*3
for i in range(3):
A[i] = [0]*3 # [0,0,0]
print(A) # [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
- 访问嵌套列表
for i in matrix:
for j in i:
print(j, end=" ")
print()
# 1 2 3
# 4 5 6
# 7 8 9
print(matrix[0]) # [1, 2, 3]
print(matrix[0][0]) # 1
1.7、浅拷贝
.copy()
x = [1, 2, 3]
y = x.copy()
x[1] = 0
print('x =', x) # x = [1, 0, 3]
print('y =', y) # y = [1, 2, 3]
- 切片
x = [1, 2, 3]
y = x[:]
x[1] = 0
print('x =', x) # x = [1, 0, 3]
print('y =', y) # y = [1, 2, 3]
1.8、深拷贝
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
y = x.copy()
x[1][1] = 0
print('x =', x) # x = [[1, 2, 3], [4, 0, 6], [7, 8, 9]]
print('y =', y) # y = [[1, 2, 3], [4, 0, 6], [7, 8, 9]]
二维列表浅拷贝出现问题（如上述代码所示）
**原因：**浅拷贝只是拷贝了外层的对象，内层对象只拷贝了引用
copy.copy()
import copy #在文件头引入
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
y = copy.copy(x) # 浅拷贝
x[1][1] = 0
print('x =', x) # x = [[1, 2, 3], [4, 0, 6], [7, 8, 9]]
print('y =', y) # y = [[1, 2, 3], [4, 0, 6], [7, 8, 9]]
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
y = copy.deepcopy(x) # 深拷贝
x[1][1] = 0
print('x =', x) # x = [[1, 2, 3], [4, 0, 6], [7, 8, 9]]
print('y =', y) # y = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
1.9、列表推导式
[表达式 for 目标元素 in 目标列表]
# 普通循环-每个元素放大两倍
x = [1, 2, 3, 4, 5]
for i in range(len(x)):
x[i] *= 2
print(x) # [2, 4, 6, 8, 10]
# 列表推导式-每个元素放大两倍
x = [1, 2, 3, 4, 5]
x = [i*2 for i in x]
print(x) # [2, 4, 6, 8, 10]
最终存入列表的值是表达式的值。
# 初始化列表
c = [i for i in range(10)]
print(c) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
s = [i for i in "shangzongxin"]
print(s) # ['s', 'h', 'a', 'n', 'g', 'z', 'o', 'n', 'g', 'x', 'i', 'n']
# ord()可以将单个字符转为Unicode编码
sord = [ord(i) for i in "shangzongxin"]
print(sord) # [115, 104, 97, 110, 103, 122, 111, 110, 103, 120, 105, 110]
# 提取二维列表某一列的元素
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
x = 1
l = [i[x] for i in matrix]
print(l) # [2, 5, 8]
# 提取 matrix 列表对角线的元素
l = [matrix[i][i] for i in range(len(matrix))]
print(l) # [1, 5, 9]
print(len(matrix)) # 3
l = [matrix[i][len(matrix[i])-1-i] for i in range(len(matrix))]
print(l) # [3, 5, 7]
# 循环创建列表时是逐个迭代修改原列表里的值
# 列表推导式是直接创建一个新的列表，然后与之前的变量名相关联
# 列表推导式创建二维列表
superl = [[0]*3 for i in range(3)]
print(superl) # [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
superl[1][1] = 1
print(superl) # [[0, 0, 0], [0, 1, 0], [0, 0, 0]]
[表达式 for 目标元素 in 目标列表 [if 语句【可选】]]
# 创建一个列表存储0~9之间所有的偶数
list = [i for i in range(10) if i % 2 == 0]
print(list)
# 从 list 中选出以 F 开头的单词
list = ["Great", "Szx", "Brilliant", "Excellent", "Fantastic"]
list_c = [i for i in list if i[0] == 'F']
print(list_c) # ['Fantastic']
先执行 for 语句，在执行 if 语句，最后执行表达式。
- 嵌套列表推导式
[
表达式 for 目标元素 in 目标列表 [if 语句【可选】]
for 目标元素1 in 目标列表1 [if 语句【可选】]
for 目标元素2 in 目标列表2 [if 语句【可选】]
...
for 目标元素n in 目标列表n [if 语句【可选】]
]
# 利用嵌套列表推导式将二维列表降维
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
list = [j for i in matrix for j in i]
print(list) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
list = [x+y for x in "abcd" for y in "abcd"]
print(list)
# ['aa', 'ab', 'ac', 'ad', 'ba', 'bb', 'bc', 'bd', 'ca', 'cb', 'cc', 'cd', 'da', 'db', 'dc', 'dd']
list = [x+y for x in "abcd" if x == 'a' for y in "abcd"]
print(list) # ['aa', 'ab', 'ac', 'ad']
list = [x+y for x in "abcd" for y in "abcd" if x != y]
print(list)
# ['ab', 'ac', 'ad', 'ba', 'bc', 'bd', 'ca', 'cb', 'cd', 'da', 'db', 'dc']
list = [x+y for x in "abcd" if x == 'a' for y in "abcd" if x != y]
print(list) # ['ab', 'ac', 'ad']
# 如果某个变量是临时的，无关紧要的可以用下划线当变量名
_ = []
_.append(4)
print(_) # 4
2、元组
2.1、创建访问
- 元组也可以存储不同类型的元素，但是元素不可被修改
# 元组 (元素1, 元素2, 元素3, ...)
mytuple = (1, 2, 3, 4, 5, "商宗鑫")
print(mytuple) # (1, 2, 3, 4, 5, '商宗鑫')
==注意：==当元组只有一个元素时，必须要有逗号！！！否则会被解析成单个元素。
- 元组定义时可以不加括号，只需要用逗号分隔即可
mytuple_1 = 1, 2, 3, 4, 5, 6, "张爱玲"
print(mytuple_1) # (1, 2, 3, 4, 5, 6, '张爱玲')
- 可以用下标访问
mytuple = (1, 2, 3, 4, 5, "商宗鑫")
print(mytuple[0]) # 1
print(mytuple[-1]) # 商宗鑫
2.2、切片
mytuple = (1, 2, 3, 4, 5, "商宗鑫")
print(mytuple[:-1]) # (1, 2, 3, 4, 5)
print(mytuple[::-1]) # ('商宗鑫', 5, 4, 3, 2, 1)
print(mytuple[2:3]) # (3,)
print(mytuple[::2]) # (1, 3, 5)
2.3、查找元素
- 元组不支持增、删、改，只能查
- 查找抹个元素出现的次数
nums = (1, 2, 3, 4, 5, 6, 1, 2, 1)
print(nums.count(1)) # 3
- 查找某个元素第一次出现的下标
nums = (1, 2, 3, 4, 5, 6, 1, 2, 1)
print(nums.index(2)) # 1
- +【拼接】 和 *【拷贝】
t1 = (1, 2)
t2 = (3,)
t1 = t1+t2 # 这里不是修改，元组为不可变对象，可以理解为 t1 变量名重新指向了新的地址。
print(t1) # (1, 2, 3)
t1 = t2*4
print(t1) # (3, 3, 3, 3)
2.4、嵌套元组
t1 = (2, 3, 1)
t2 = ("szx", "zal")
t3 = (t1, t2)
print(t3) # ((2, 3, 1), ('szx', 'zal'))
- 迭代访问
t1 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
for i in t1:
print(i, end=" ")
# 1 2 3 4 5 6 7 8 9 0
t2 = ((2, 3, 1), ('szx', 'zal'))
for i in t2:
for j in i:
print(j, end=" ")
# 2 3 1 szx zal
- 列表推导式遍历元组 不存在元组推导式
t1 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
list1 = [i for i in t1 if i % 2 == 0]
print(list1) # [2, 4, 6, 8, 0]
2.5、元组打包
- 打包就是生成元组
t = (123, "szx", 2.3545)
2.6、元组解包
- 解包是将元组拆开赋值给若干变量，变量个数与元素个数相等，否则报错，或者加 *
t = (123, "szx", 2.3545)
*x, y = t
print(x, y) # [123, 'szx'] 2.3545
x, *y = t
print(x, y) # 123 ['szx', 2.3545]
a, b, c = t
print(a, b, c) # 123 szx 2.3545
# 列表也可以解包
a, b, c = [1, "iop", 2.343]
print(a, b, c) # 1 iop 2.343
# 字符串也可以解包
a, b, c = "szx"
print(a, b, c) # s z x
补充：
- 当元组内元素为可变对象时是可以修改元组内的元素的
t = ([1, 2, 3], [3, 4, 5])
t[1][1] = 0
print(t) # ([1, 2, 3], [3, 0, 5])
3、字符串（方法）
3.1、大小写转换
# 大小写字母切换
str = "I love Python!"
# str.capitalize() 首字母大写，其他字母小写
print(str.capitalize()) # I love python!
# str.casefold() 所有字母小写【可以处理其他语言】
print(str.casefold()) # i love python!
# str.title() 每个单词首字母大写，其他小写
print(str.title()) # I Love Python!
# str.swapcase() 大小写翻转
print(str.swapcase()) # i LOVE pYTHON!
# str.upper() 所有字母大写
print(str.upper()) # I LOVE PYTHON!
# str.lower() 所有字母小写【只能处理英语】
print(str.lower()) # i love python!
3.2、左中右对齐
# 左中右对齐
str = "szx"
# str.center(width, fillchar='') 居中，不够分则右边多
print(str.center(10, "*")) # ***szx****
# str.ljust(width, fillchar='') 左对齐
print(str.ljust(10, "*")) # szx*******
# str.rjust(width, fillchar='') 右对齐
print(str.rjust(10, "*")) # *******szx
# str.zfill(width) 在左侧填充 0
print(str.zfill(10)) # 0000000szx
3.3、字符串查找
# 查找
str = "Shangzongxin 123456789 你好"
# str.count(sub[,start[,end]]) 统计子串在字符串中出现的次数，可指定起点与终点
print(str.count(' ')) # 2
print(str.count(' ', 0, -3)) # 1
print(str.count(' ', 13)) # 1
# str.find() 与 str.rfind() 未找到子串时返回 -1
# str.find(sub[,start[,end]]) 获取指定子串第一次出现的位置【第一个字符的下标】
print(str.find(' ')) # 12
print(str.find('ng')) # 3
# str.rfind(sub[,start[,end]]) 获取指定子串最后一次出现的位置【第一个字符的下标】
print(str.rfind(' ')) # 22
print(str.rfind('ng')) # 7
# str.index() 与 str.rindex() 未找到子串时报错
# str.index(sub[,start[,end]]) 获取指定子串第一次出现的位置【第一个字符的下标】
print(str.index(' ')) # 12
print(str.index('ng')) # 3
# str.rindex(sub[,start[,end]]) 获取指定子串最后一次出现的位置【第一个字符的下标】
print(str.rindex(' ')) # 22
print(str.rindex('ng')) # 7
3.4、字符串替换
# 替换
str = "\t我\t是\t商\t宗\t鑫\t。AbcdEfgAbcdEfgAbcdEfg"
print(str) # 我 是 商 宗 鑫 。
# str.expandtabs([tabsize=8]) 使用空格替换制表符
print(str.expandtabs(0)) # 我是商宗鑫。
# str.replace(old,new,count=-1) 将old替换为new，count代表替换的次数，-1代表全部替换，count过大按全部算
print(str.replace("Ab", "++", 1))
# 我 是 商 宗 鑫 。++cdEfgAbcdEfgAbcdEfg
print(str.replace("Ab", "++", 2))
# 我 是 商 宗 鑫 。++cdEfg++cdEfgAbcdEfg
print(str.replace("Ab", "++"))
# 我 是 商 宗 鑫 。++cdEfg++cdEfg++cdEfg
print(str.replace("Ab", "++", 5))
# 我 是 商 宗 鑫 。++cdEfg++cdEfg++cdEfg
# str.translate(table) 返回一个根据table规则生成的新字符串
table = str.maketrans("ABCDEFGI", "12345678")
print("I love pyhton A BA A BA A BA!".translate(table))
# 8 love pyhton 1 21 1 21 1 21!
table = str.maketrans("ABCDEFGI", "12345678", "I") # 将 "I" 忽略掉，删去，空格占位
print("I love pyhton A BA A BA A BA!".translate(table))
# love pyhton 1 21 1 21 1 21!
3.5、字符串判断
str = "ABCabcabcABC"
# str.startswith(prefix[,start[,end]]) 以什么开头，可以用元组传参
print(str.startswith("ABC")) # True
print(str.startswith(("a", "B", "A"))) # True
# str.endswith(suffix[,start[,end]]) 以什么结尾
print(str.endswith("ABC")) # True
# str.isupper() 是否全部大写
# str.islower() 是否全部小写
# str.istitle() 所有单词首字母是否大写
print(str.istitle()) # False
print(str.title().istitle()) # True
# str.isalpha() 是否全是字母
# str.isascii() 如果字符串为空或字符串中的所有字符都是 ASCII，则返回 True，否则返回 False。
# str.isspace() 是否是空白字符串
# str.isprintable() 是否可以打印 转义字符不可打印
# str.isdecimal() 检查字符串是否只包含十进制字符 【0】
# str.isdigit() 检测字符串是否只由数字组成，只对 0 和 正数有效 【1】
# str.isnumeric() 指定的表达式是否可作为数字来计算 【2】
# str.isalnum() 检测字符串是否由字母和数字组成 【3】【数字越大范围越大】 isdecimal isdigit isnumeric 中任何一个返回True，就返回True
# str.isidentifier() 是否是合法的标识符
3.6、字符串截取
# 截取
str = " www.shangzongxin.com "
# str.strip() 【按照单个字符匹配剔除】用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列
print(str.strip()) # www.shangzongxin.com
str = "www.shangzongxin.com"
print(str.strip("w.com")) # shangzongxin
print(str.strip("w.co")) # shangzongxin.com
print(str.strip(".wcom")) # shangzongxin
# str.lstrip() 【按照单个字符匹配剔除】用于截掉字符串左边的空格或指定字符
# str.rstrip() 【按照单个字符匹配剔除】删除 string 字符串末尾的指定字符，默认为空白符，包括空格、换行符、回车符、制表符
# str.removeprefix(prefix) 删除指定前缀
print(str.removeprefix("w")) # ww.shangzongxin.com
# str.removesuffix(suffix) 删除指定后缀
print(str.removesuffix(".com")) # www.shangzongxin
3.7、字符串拆分
# 拆分
str = "abcabcabc"
# str.partition(sep) 【从左往右】根据指定的分隔符将字符串进行分割。
# 如果字符串包含指定的分隔符，则返回一个3元的元组，
# 第一个为分隔符左边的子串，
# 第二个为分隔符本身，
# 第三个为分隔符右边的子串。
print(str.partition("c")) # ('ab', 'c', 'abcabc')
# str.rpartition(sep) 【从右往左】根据指定的分隔符将字符串进行分割。
print(str.rpartition("c")) # ('abcabcab', 'c', '')
# split(sep=None,maxsplit=-1) 【从左往右】
# rsplit(sep=None,maxsplit=-1) 【从右往左】
# 通过指定分隔符对字符串进行切片，默认以空格分割，
# 如果参数 maxsplit 有指定值，则分隔 maxsplit+1 个子字符串
# 返回列表
print(str.split()) # ['abcabcabc']
print(str.split("b")) # ['a', 'ca', 'ca', 'c']
print(str.rsplit()) # ['abcabcabc']
print(str.rsplit("b")) # ['a', 'ca', 'ca', 'c']
print(str.split("b", 2)) # ['a', 'ca', 'cabc']
print(str.rsplit("b", 2)) # ['abca', 'ca', 'c']
# splitlines() 将字符串按行分割【每个操作系统换行符不一样，所以不能简单用split与rsplit】
str = "sdf\ndsds\r\ndwdec\rdcdc"
print(str.rsplit("\n")) # ['sdf', 'dsds\r', 'dwdec\rdcdc']
print(str.splitlines()) # ['sdf', 'dsds', 'dwdec', 'dcdc']
3.8、字符串拼接
# 拼接
# join(iterable)
str = ".".join(["www", "baidu", "com"])
print(str) # www.baidu.com
str = "".join(("www", ".baidu", ".com")) # 拼接效率更高，比 + 高
print(str) # www.baidu.com
str = " ".join("www")
print(str) # w w w
3.9、格式化字符串
# 格式化字符串
# format()
str = "我是{}"
str1 = str.format("商宗鑫")
print(str1) # 我是商宗鑫
str = "{}{}{}{}跳了一支孔雀舞。"
str4 = str.format("校长", "给", "爷爷", "我")
print(str4)
# 校长给爷爷我跳了一支孔雀舞。
str = "{0}{1}{2}{3}跳了一支孔雀舞。"
str1 = str.format("我", "给", "校长", "爷爷")
print(str1) # 我给校长爷爷跳了一支孔雀舞。
str = "{three}{four}{two}{one}跳了一支孔雀舞。"
str1 = str.format(one="我", two="给", three="校长", four="爷爷")
print(str1) # 校长爷爷给我跳了一支孔雀舞。
print("{},{{}},{}".format(1, {})) # 1,{},{}
# ^, <, > 分别是居中、左对齐、右对齐，后面带宽度
# = 强制将填充符号放置在符号（如果有）之后，但在数字之前（适用于+0000120）
# + 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
# b、d、o、x 分别是二进制、十进制、八进制、十六进制。
# {序号:填充 = 对齐 占位} = 与对齐不能同时写
print("{:^20}".format(250)) # 250
print("{0:<5}{1:>5}".format(250, 520)) # 250 520
print("{one:<5}{two:>5}".format(one=250, two=520)) # 250 520
print("{:05}".format(+25)) # 00025 只对数字有效，只能填充0，否则输出空串
print("{:05}".format(-25)) # -0025 只对数字有效，只能填充0，否则输出空串
print("{:*>10}".format(25)) # ********25
print("{:*^10}".format(25)) # ****25****
print("{:2^10}".format(25)) # 2222252222
# print("{:*10}".format(25)) # 非0数字填充时不指定对齐方式会报错或输出空
print("{:*=10}".format(25)) # ********25 加等号正常输出
print("{:4=10}".format(25)) # 4444444425 加等号正常输出
# print("{:7=>10}".format(14)) # = 与对齐不能同时写
print("{:7>10}".format(14)) # 7777777714
# {:+} 格式化正数
# {:-} 格式化负数
# {:,} 千分位分隔符
# {:_} 千分位分隔符
# {:.nf} 小数点后n位，不允许整数
# {:.ng} 小数点前后共n位
# {:.n} 非数字类型，如字符串截取前n位
# {:b} 二进制形式
# {:c} Unicode字符形式
# {:d} 十进制形式
# {:o} {:#o}八进制形式
# {:x} {:#x}十六进制形式
# {:X} {:#X}十六进制形式
# {:n} 类似 d ,不同之处在于它会使用当前语言环境设置分隔符插入到恰当的位置
# {:None} 类似 g
# {:%} 乘以100加%
# f 字符串
year = 2023
str = f"今年是{year}年。"
print(str) # 今年是2023年。
a = 1+2
b = pow(2, 2)
c = pow(2, 3)
str = f"1 + 2 = {a}, 2² = {b}, 2³ = {c}"
print(str) # 1 + 2 = 3, 2² = 4, 2³ = 8
str = f"{0.98:.0%}"
print(str) # 98%
4、序列（方法）
-
列表、元组、字符串都属于序列
-
+ 【拼接】、* 【拷贝】
-
id (对象) 获取对象的唯一标识
-
is、is not同一性运算符—检测对象的id值是否相等
x = "商宗鑫"
y = "商宗鑫"
print(x is y) # True 字符串为不可变对象
in、not in判断某个元素是否包含在序列中
List = [1, 2, 3, 4, 5]
print(1 in List) # True
print("商宗" in "商宗鑫") # True
del用于删除一个或多个指定的对象/也可以删除可变序列中的指定元素
# 删除一个或多个指定的对象
x = [1, 2, 3]
y = "szx"
z = (1, 2, 3)
print(x, y, z) # [1, 2, 3] szx (1, 2, 3)
del x, y, z
# print(x, y, z) #报错
# 删除可变序列中的指定元素
List = [1, 2, 3]
del List[2]
print(List) # [1, 2]
del List[:]
print(List) # []
List = [1, 2, 3, 4, 5, 6, 7, 8, 9]
del List[::2]
print(List) # [2, 4, 6, 8]
# 删除不可变元素会报错
# str = "szx"
# del str[0]
# print(str)
- 列表、元组、字符串相互转换的函数
# list()
# 字符串->列表
Str = "shangzongxin"
List = list(Str)
print(List) # ['s', 'h', 'a', 'n', 'g', 'z', 'o', 'n', 'g', 'x', 'i', 'n']
# 元组->列表
tu = (1, 2, 3, 4, 5)
List = list(tu)
print(List) # [1, 2, 3, 4, 5]
# tuple()
# 字符串->元组
Str = "shangzongxin"
Tuple = tuple(Str)
print(Tuple) # ('s', 'h', 'a', 'n', 'g', 'z', 'o', 'n', 'g', 'x', 'i', 'n')
# 列表->元组
List = [1, 2, 3, 4, 5, 6]
Tuple = tuple(List)
print(Tuple) # (1, 2, 3, 4, 5, 6)
# str()
# 列表->字符串
List = [1, 2, 3, 4, 5]
Str = str(List)
print(Str) # '[1, 2, 3, 4, 5]' 字符串类型
# 元组->字符串
Tuple = (1, 2, 3, 4, 5)
Str = str(Tuple)
print(Str) # '(1, 2, 3, 4, 5)' 字符串类型
min、max获取最小值和最大值
# min() 对比传入的参数获取最小值
List = [1, 2, 3, 4, 5, 6]
print(min(List)) # 1
# max() 对比传入的参数获取最大值
List = [1, 2, 3, 4, 5, 6]
print(max(List)) # 6
print(min("abcd")) # a
print(max("abcd")) # d
# 不能传入空对象否则报错，可用default设置默认参数
print(min([], default="不能传入空对象！")) # 不能传入空对象！
len()获取对象长度，len函数参数不能太长否则会报错
print(len("123")) # 3
sum()求和
print(sum([1, 2, 3, 4, 5])) # 15
print(sum([1, 2, 3, 4, 5], start=100)) # 115
sorted()返回新的列表，而sort原地修改
sort()只能处理列表sorted()可以处理所有可迭代对象，返回列表
print(sorted([2, 1, 3, 42, 21], reverse=True)) # [42, 21, 3, 2, 1]
List = ["afefd", "ads", "fdfd", "ewewwewewew"]
print(sorted(List, key=len)) # ['ads', 'fdfd', 'afefd', 'ewewwewewew']
# ['ads', 'fdfd', 'afefd', 'ewewwewewew'] 利用len()排序
reversed()返回参数的反向迭代器,支持所有可迭代对象
print(reversed([1, 2, 5, 8, 0]))
# list_reverseiterator object at 0x000001F86CA17DF0>
print(list(reversed([1, 2, 5, 8, 0]))) # [0, 8, 5, 2, 1]
all()判断可迭代对象中是否所有元素都为真
print(all([1, 2, 3])) # True
print(all([0, 1, 2])) # False
any()判断可迭代对象中是否存在值为真的元素
print(any([1, 2, 0])) # True
print(any([0, 0, 0])) # False
enumerate(iterable,start)返回一个枚举对象
# 用于返回一个枚举对象，它的功能就是将可迭代对象中得每个元素
# 及从零开始的序号共同构成的一个二元组的列表。
print(enumerate(["春", "夏", "秋", "冬"]))
# <enumerate object at 0x0000016385D53A10>
print(list(enumerate(["春", "夏", "秋", "冬"])))
# [(0, '春'), (1, '夏'), (2, '秋'), (3, '冬')]
zip()创建一个聚合多个迭代器对象的迭代器
# zip()
# 用于创建一个聚合多个迭代器对象的迭代器【长度不一样，以最短的为准】
# 它会将作为参数传入的每个迭代器对象的每个元素依次组合成元组
# 即第 i 个元组包含来自每个参数的第 i 个元素。
print(list(zip([1, 2, 3], "szx", ("你", "我", "它"))))
# [(1, 's', '你'), (2, 'z', '我'), (3, 'x', '它')]
import itertools 【引入，可解决长度不一问题】
print(list(itertools.zip_longest([1, 2, 3], "szx123", ("你", "我", "它"))))
# [(1, 's', '你'), (2, 'z', '我'), (3, 'x', '它'), (None, '1', None), (None, '2', None), (None, '3', None)]
map()【可迭代参数长度不一致以短的为主】
# map() 【可迭代参数长度不一致以短的为主】
# 会根据提供的函数对指定的可迭代对象的每个元素进行运算，返回运算结果的迭代器
print(list(map(ord, "12345"))) # [49, 50, 51, 52, 53]
print(list(map(pow, [1, 2, 3], [2, 2, 2]))) # [1, 4, 9] 不止一个参数
filter()
# 根据提供的函数对指定的可迭代对象的每个元素进行运算,将运算结果为真的元素，以迭代器的形式返回
print(list(filter(str.islower, "Aszxc"))) # ['s', 'z', 'x', 'c']
补充：
迭代器一定是可迭代对象
可迭代对象可以重复使用，迭代器是一次性的
mapped = map(ord, "123")
for i in mapped:
print(i)
# 49
# 50
# 51
print(list(mapped)) # []
# iter() 可迭代对象转迭代器
print(type(iter([1, 2, 3]))) # <class 'list_iterator'>
# next() 提取迭代器中的元素
List = [1, 2, 3, 4, 5]
Iter = iter(List)
print(next(Iter)) # 1
print(next(Iter)) # 2
print(next(Iter)) # 3
print(next(Iter)) # 4
print(next(Iter)) # 5
# print(next(Iter)) # 报错异常
List = [1, 2, 3, 4, 5]
Iter = iter(List)
print(next(Iter, "没啦！")) # 1
print(next(Iter, "没啦！")) # 2
print(next(Iter, "没啦！")) # 3
print(next(Iter, "没啦！")) # 4
print(next(Iter, "没啦！")) # 5
print(next(Iter, "没啦！")) # 没啦！
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
