Python基础语法上（查漏补缺版）

格式化输出

#格式输出
name="张三"
month=10
change=56.7
balance=23.3
print("亲爱的%s 您好，您%d月的话费是%.2f,余额为%.2f"%(name,month,change,balance))

Python 中，一切皆对象。每个对象由：标识(identity)、类型(type)、value(值)组成。对象的本质就是：一个内存块，拥有特定的值，支持特定类型的相关操作。

在 Python 中，变量也成为：对象的引用。因为，变量存储的就是对象的地址。变量通过地址引用了“对象”。

变量位于：栈内存；对象位于：堆内存。

Python 是动态类型语言：变量不需要显式声明类型。根据变量引用的对象，Python 解释器自动确定数据类型。

Python 是强类型语言：每个对象都有数据类型，只支持该类型支持的操作。

系列解包赋值

#系列赋值，给多个变量赋值
a,b=10,20
print('a:',a)
print('b:',b)
print('交换变量后')
#实现变量交换
b,a=a,b
print('a:',a)
print('b:',b)

# 使用 del 语句删除变量
#定义变量 x y
x=23
y='abc' print('x:',x)
print('y:',y)
print('使用 del 删除变量后')
#使用 del 删除变量
del y
print('x:',x)
print('y:',y

数据类型

Sequence 类型簇：可以将字符串看作由字符组成的序列类型，包括 String、Tuple、List三种类型

运算符

算术运算符

#基本运算符的使用
print(3+4) #运算结果:7
print(129-789) #运算结果:-660
print(5+20*5) #运算结果:105
print(1/4) #运算结果:0.25
print(8/2) #运算结果:4.0
print(8//3) #运算结果:2
print(8%3) #运算结果:2
print(4**3) #运算结果 64

关系运算符

#测试比较运算符
a,b,c=30,20,10
print("a 大于 b:",(a>b)) #输出结果：True
print("a 大于等于 b:",(a>=b)) #输出结果：True
print("b 小于等于 c：",(b<=c)) #输出结果:False
print("a 等于 c：",(a==c)) #输出结果：False

逻辑运算符

#测试逻辑运算符
a,b,c=10,20,30
print((a<b) and (b<c)) #and 并且 输出结果是 True
print((a>b) or (b>c)) #or 或者 输出结果是 False
print(not(b<c)) #not 非 输出结果是 False

赋值运算符

#加法赋值运算符
a=3
b=4
a+=b
print('a:',a,"\tb:",b)
#乘法赋值运算符
a=3
a*=b
print('a:',a,"\tb:",b)
#除法赋值运算符
a=10
b=5
a/=b
print('a:',a,"\tb:",b)
#取模赋值运算符
a=9
b=4
a%=b
print('a:',a,"\tb:",b)
#测试幂赋值运算符
a=2
b=3
a**=b
print('a:',a,"\tb:",b)
#取整除赋值运算符
a=8
b=2
a//=b
print('a:',a,"\tb:",b)

位运算符

# 演示位运算符
a=6 #0000 0110
b=3 #0000 0011
c=a&b #0000 0010
print('按位与结果 c 的值为',c) #2
c=a|b #0000 0111
print('按位或结果 c 的值为',c) #7
c=a^b #0000 0101
print('按位异或结果 c 的值为',c)#5
c=~a #类似于-a-1
print('按位取反结果 c 的值为',c)#-7
c=a<<2 #00011000
print('左移 2 位结果 c 的值为',c) #24
c=a>>2 #00000001
print('右移 2 位结果 c 的值为',c) #1
# -----------结果---------------
# 按位与结果 c 的值为 2
# 按位或结果 c 的值为 7
# 按位异或结果 c 的值为 5
# 按位取反结果 c 的值为 -7
# 左移 2 位结果 c 的值为 24
# 右移 2 位结果 c 的值为 1

成员运算符

# 演示成员运算符
a=10
b=20
list=[1,2,3,4,5,20]
print('a 在列表中',(a in list)) #False
print('b 在列表中',(b in list)) #True
print('a 不在列表中',(a not in list)) #True
print('b 不在列表中',(b not in list)) #False

身份运算符

#测试身份运算符
a=20
b=20
c=30
print("a 和 b 是同一个对象",a is b) #执行结果:True
print("a 和 c 是同一个对象",a is c) #执行结果 False
print("a 和 c 不是同一个对象",a is not c) #执行结果 True

运算符的优先级

#测试运算符优先级
a,b,c,d=20,10,15,5
e=(a+b)*c/d #30*15/5
print('(a+b)*c/d 的执行结果:',e)
e=(a+b)*(c/d) #30*(15/5)
print('(a+b)*(c/d)的执行结果：',e)
e=a+(b*c)/d #20+150/5
print('a+(b*c)/d 的执行结果：',e)

进制的转换

#二进制、八进制、十进制和十六进制数之间的转换
print(0b110110) #输出二进制数 输出结果:54
print(0o234) #输出八进制 输出结果:156
print(0xF45) #输出十六进制 输出结果:3909
print(bin(12345)) #十进制转换为二进制 输出结果:0b11000000111001
print(int('110110',2)) #二进制转换为十进制 输出结果:54
print(int('ABC',16)) #十六进制转换为十进制 输出结果:2748
print(hex(123456)) #十进制转换为十六进制 输出结果: 0x1e240
print(hex(0b11100001)) #二进制转换为十六进制 输出结果:0xe1
print(oct(123456)) #十进制转换为八进制 输出结果:0o361100
print(int('123456',8)) #八进制转十进制 输出结果：42798

大整数

#测试非常大的数，看看会不会溢出
print(2**36) #2 的 36 次幂
print(2**300) #2 的 300 次幂

很显然，Python 语言仍然可以正确处理 2**600 的计算结果。因此，在 Python 语言中使用数字不需要担心溢出，因为 Python 语言可以处理非常大的数字，这也是为什么很多人 使用 Python 语言进行科学计算和数据分折的主要原因。

浮点

#测试浮点数进行/(整除)、//(取整)、%(取余运算符)和**(幂运算符)
print(9.0/2) #整除输出结果:4.5
print(9.0//2) #取整输出结果:4.0
print(9.0%2) #取余输出结果:1.0
print(4.3**2) #幂次输出结果:18.49

转义字符

#测试转义字符
a = 'I\nLove\nPython' #\n 换行符
print(a)
b="aa\tbb\tcc" #\t 制表符
print(b)
c='Let\'s go' #单引号中同时包含单引号使用\'进行转义
print(c)

字符串

字符串创建

#创建字符串
s1='hello world' 
s2="I love Python" 
print(s1)
print(s2)

字符串拼接

#字符串拼接
a='Hello'
b='World'
c=a+b #使用加号进行字符串拼接
print(c)
c='Hello"World' #将多个字面字符串直接放到一起实现拼接
print(c)

字符串复制

#字符串复制
a = 'Sxt'*3
print(a)

字符串的下标和切片

# 字符串索引获取字符
s='Hello Python' 
print('获取 s 的第 1 个字符:',s[0]) #获取 s 的第 1 个字符，运行结果是 H
print('获取 s 的第 5 个字符:',s[4]) #获取 s 的第 5 个字符，运行结果是 o
print('获取 s 的最后一个字符:',s[-1]) #获取 s 的最后一个字

# 下标为正数
s='abcdef'
print(s[:]) #start 和 end 都省略，截取整个字符串 输出结果：abcdef
print(s[2:]) #end 省略，从 start 开始到结束 输出结果:cdef
print(s[:2]) #start 省略 从 0 开始到 end-1 输出结果:ab
print(s[2:4]) #从 start 开始到 end-1 输出结果:cd
print(s[1:5:2]) #从 start 提取到 end-1，步长是 step 输出结果:bd

# 下标为负数
s='abcdefghijklmnopqrstuvwxyz'
print(s[-3:]) #从倒数第三个开始到结束 输出结果 xyz
print(s[-8:-3])#从倒数第八个开始到倒数第四个 输出结果 stuvw
print(s[::-1]) #步长为-1，从右向左截取 输出 zyxwvutsrqponmlkjihgfedcba

字符串的格式化

使用 format 实现字符串格式化

s="姓名:{0},年龄:{1},薪资:{2}"
print(s.format('张三',23,13000))
c = "名字是{name}，年龄是{age}"
print(c.format(age=19,name='李四'))

使用 format 实现填充对齐

format 方法可以控制值的左、中、右对齐， “^”、“<”、“>”分别是居中、左对齐、右对齐，后面带宽度。“:”号后面带填充的字符，只能是一个字符，不指定的话默认 是用空格填充。

print("{:*>8}".format("245"))
print("{:#^20}".format("Python"))

数字格式化

使用 format 实现数字格式化

a = "我是{0}，我的存款有{1:.2f}"
print(a.format("张三",3888.234342))

字符串的常用方法

1)find()

find 方法可以在一个较长的字符串中查找子串，它返回子串的第一个字符在大字符串中出现的位置。如果没有找到则返回-1。find 方法还可以指定开始和结束查找的位置。

a='Hello Python'
b=a.find('P')
print('字符 P 在字符串 Hello Python 中的位置{0}'.format(b))
b=a.find('Hello')
print('字符 P 在字符串 Hello Python 中的位置{0}'.format(b))
#指定开始查找子串位置
b=a.find('o',6)
print('从索引 6 开始查找字符 o 在字符串 Hello Python 中的位置{0}'.format(b))
#指定开始和结束查找子串位置
b=a.find('o',2,6)
print('从索引 2 开始到索引 6 查找字符 o 在字符串 Hello Python 中的位置{0}'.format(b))

2)index()

跟 find()方法一样，区别是如果查找的子串不在原字符串中 index 会报异常，而 find 没有找到则返回-1。

a='Hello Python'
b=a.index('l') #l 第一次出现的索引 输出结果:2
print(b)
b=a.find('s') #find 方法未检索到返回-1 输出结果:-1
print(b)
b=a.index('s') #index 方法未检索到抛出异常
print(b)

3) count()

统计子串在原字符串中出现的次数。

a='Hello Python'
b=a.count('o') #统计 o 字符在字符串中的个数 输出结果:2
print('统计字符 o 出现的次数：',b)
#指定开始索引统计
c=a.count('o',6,len(a))
print('从索引 6 开始统计字符 o 出现的次数：',c)

4) replace()

a='Hello Python'
b=a.replace('o','*') #将 Hello Python 字符串中的 o 替换为* 默认全部替换
c=a.replace('o','*',1) #将 Hello Python 字符串中的 o 替换为* 替换 1 次
print(a)
print(b)
print(c)

5) split()分割和 join()合并

split 方法通过分隔符将一个字符串拆分成一个序列。如果 split 方法不指定任何参数，那么 split 方法会把所有空格(空格符、制表符、换行符)作为分隔符。 join 方法用于连接序列中的元素，是 split 方法的逆方法。

#split 方法测试
a='This is my first Progame'
b=a.split(" ",2)
print(b)
a = "to be or not to be"
b=a.split()
print(b)
#join 方法测试
a = ['sxt','sxt100','sxt200']
print('*'.join(a))

6) capitalize()、lower()、upper()、title()、swapcase()

a='Hello python' #将 Hello python 转换为大写
print('upper 全部大写:',a.upper())
#将 Hello python 转换为小写
print('lower 全部小写:',a.lower())
#将 Hello python 首字母大写
print('capitalize 首字母大写:',a.capitalize())
#将 Hello python 每个单词首字母转换为大写
print('title 每个单词首字母大写:',a.title())
#将 Hello python 字母大小写转换
print('swapcase 字母大小写转换:',a.swapcase())

7) startswith()、endswith()

startwith 检索字符串是否以指定字符串开始，如果是则返回 True，否则返回 False。endwith 检索字符串是否以指定字符串结尾，如果是则返回 True，否则返回 False。

a='hello python'
print('是否以字符 h 开头:',a.startswith('h'))
print('是否以字符 h 结尾:',a.endswith('h'))

8) center()、ljust()、rjus

center 方法用于将一个字符串在一定宽度的区域居中显示，并在字符串的两侧填充指定的字符，默认填充空格。前面将的 format 方法和居中符号(^)，其实完全可以用 format 方法 代替 center 方法实现同样的效果，只是使用 center 方法更简单，更直接一些。

ljust()返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串,默认是空格 填充。

rjust()返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串。

a='SXT'
print(a.center(10,"*"))
print(a.center(10))
print(a.ljust(10,"*"))
print(a.rjust(10,"*"))

9) strip()、lstrip()、rstrip()

lstrip 方法删除原字符串左边的空白字符，rstrip 方法删除原字符串右边的空白字符，strip删除原字符串两端的空白字符。

a='          hellopython             '
print(a.strip())
print(a.lstrip())
print(a.rstrip())

10) 其他方法

# 字符串其他方法的使用
#是否为字母或数字
print("sxt100".isalnum())
#检测字符串是否只由字母组成(含汉字)
print("sxt 尚学堂".isalpha())
#检测字符串是否只由数字组成
print("234.3".isdigit())
print("2343".isdigit())
#检测是否为空白符
print("sxt\t\n".isspace())
print("\t\n".isspace())
#是否为大写字母
print("A".isupper())
print('Ab'.isupper())
#是否为小写字母
print("a".islower())
print("aB".islower())

可变字符串

在 Python 中，字符串属于不可变对象，不支持原地 修改，如果需要修改其中的值，智能创建新的字符串对象。但是，经常需要原地修改字符串，可以使用 io.StringIO 对象或 array 模块。

import io
s = "hello,bjsxt"
sio = io.StringIO(s)
print(sio)
print('原字符串：',sio.getvalue())
sio.seek(7)
sio.write("g")
print('修改后字符串：',sio.getvalue())

不换行输出

#print()不换行输出
print("sxt",end=' ')
print("sxt",end='##')
print("sxt")

数据类型转换

# 类型转换
#转换为 int
print('int()默认情况下为：', int())
print('str 字符型转换为 int：', int('010'))
print('float 浮点型转换为 int：', int(234.23))
#十进制数 10，对应的 2 进制，8 进制，10 进制，16 进制分别是：1010,12,10,0xa
print('int(\'0xa\', 16) = ', int('0xa', 16))
print('int(\'10\', 10) = ', int('10', 10))
print('int(\'12\', 8) = ', int('12', 8))
print('int(\'1010\', 2) = ', int('1010', 2))
#转换为 float
print('float()默认情况下为：', float())
print('str 字符型转换为 float：', float('123.01'))
print('int 浮点型转换为 float：', float(32))
#转换为 complex
print('创建一个复数(实部+虚部)：', complex(12, 43))
print('创建一个复数(实部+虚部)：', complex(12))
#转换为 str 字符串
print('str()默认情况下为：', str())
print('float 字符型转换为 str：', str(232.33))
print('int 浮点型转换为 str：', str(32))
lists = ['a', 'b', 'e', 'c', 'd', 'a']
print('列表 list 转换为 str:', ''.join(lists))
#转换为 list
strs = 'hongten'
print('序列 strs 转换为 list:', list(strs))
#转换为 tuple
print('列表 list 转换为 tuple:', tuple(lists))
#字符和整数之间的转换
print('整数转换为字符 chr:', chr(67))
print('字符 chr 转换为整数:', ord('C'))
print('整数转 16 进制数:', hex(12))
print('整数转 8 进制数:', oct(12))

布尔值和布尔变量

布尔(boolean)类型有两个值：True 和 False，可以将这两个值翻译成“真”和“假”。在 Python 语言中有一些特殊的布尔类型值为 False，例如 False、0、0.0、空值 None、空 序列对象(空列表、空元祖、空集合、空字典、空字符串)、空 range 对象、空迭代对象，其 他情况，均为 True

print('空字符串的布尔类型的值:',bool(""))
print('空列表布尔类型的值:',bool([]))
print('空元组布尔类型的值:',bool(()))
print('空字典布尔类型的值:',bool({}))
print('None 布尔类型的值:',bool(None))
print('0 布尔类型的值:',bool(0))

# 测试 True 和 1, False 和 0 是相同的
print("True==1 的结果:",True==1)
print("False==0 的结果:",False==0)
print("True+False+20 的计算结果:",True+False+20)

流程控制

条件判断语句(只展示样例，一看即懂)

num = input("请输入一个整数：")
if int(num)<10: #获取的 num 是字符串，所以使用 int()函数进行转换
    print('您输入的整数是:',num)

num = input("请输入一个整数：")
if int(num)<10: #获取的 num 是字符串，所以使用 int()函数进行转换
    print('您输入的整数是:',num)
else:
    print('数字过大')

score = int(input("请输入分数"))
grade = ''
if score < 60:
    grade = "不及格"
elif score < 80:
    grade = "及格"
elif score < 90:
    grade = "良好"
elif score <= 100:
    grade = "优秀"
print("分数是{0},等级是{1}".format(score, grade))

# 已知点的坐标(x,y), 判断其所在的象限
x = int(input("请输入 x 坐标"))
y = int(input("请输入 y 坐标"))
if(x==0 and y==0):print("原点")
elif(x==0):print("y 轴")
elif(y==0):print("x 轴")
elif(x>0 and y>0):print("第一象限")
elif(x<0 and y>0):print("第二象限")
elif(x<0 and y<0):print("第三象限")
else:
    print("第四象限")

选择结构的嵌套

score = int(input("请输入一个在 0-100 之间的数字："))
grade = ""
if score>100 or score<0:
    score = int(input("输入错误！请重新输入一个在 0-100 之间的数字："))
    if score>=90:
        grade = "A"
    elif score>=80:
        grade = 'B'
    elif score>=70:
        grade = 'C'
    elif score>=60:
        grade = 'D'
    else:
        grade = 'E'
    print("分数为{0},等级为{1}".format(score,grade))
else:
    if score>=90:
        grade = "A"
    elif score>=80:
        grade = 'B'
    elif score>=70:
        grade = 'C'
    elif score>=60:
        grade = 'D'
    else:
        grade = 'E'
    print("分数为{0},等级为{1}".format(score,grade))

循环语句

while循环

num = 0
while num<=10:
    print(num)
    num += 1

num = 1
sum_all = 0  # 1-100 所有数的累加和
sum_even = 0  # 1-100 偶数的累加和
sum_odd = 0  # 1-100 奇数的累加和
while num <= 100:
    sum_all += num
    if num % 2 == 0:
        sum_even += num
    else:
        sum_odd += num
    num += 1  # 迭代，改变条件表达式，使循环趋于结束
print("1-100 所有数的累加和", sum_all)
print("1-100 偶数的累加和", sum_even)
print("1-100 奇数的累加和",sum_odd)

for循环

#for 循环遍历字符串
for x in "sxt 计算机":
    print(x)

sum_all = 0  # 1-100 所有数的累加和
sum_even = 0  # 1-100 偶数的累加和
sum_odd = 0  # 1-100 奇数的累加和
for num in range(101):
    sum_all += num
    if num % 2 == 0:
        sum_even += num
    else:
        sum_odd += num
print("1-100 累加总和{0},奇数和{1},偶数和{2}".format(sum_all, sum_odd, sum_even))

循环嵌套

for x in range(5):
    for y in range(5):
        print(x,end="\t")
    print() #仅用于换行

# 九九乘法表
for m in range(1, 10):
    for n in range(1, m + 1):
        print("{0}*{1}={2}".format(m, n, (m * n)), end="\t")
    print()

循环中的 else 语句

如果for、while 语句没有被 break 语句结束，则会执行else子句， 否则不执行。

while 循环中的 else 语句

# while else
num = 0
while num < 5:
    print(num, '的值小于 5')
    num += 1
else:
    print('循环正常结束，num 的值:', num)

for 循环中的 else 语句

# for语句被break终止，所以不执行else语句
for num in range(1, 10):
    if num == 10:
        print(num)
    break
else:
    print('正常退出循环')

for num in range(1, 10):
    if num == 10:
        print(num)
        break
else:
    print('正常退出循环')

break

break 语句可用于 while 和for 循环，用来结束整个循环。 当有嵌套循环时，break 语句只能跳出最近一层的循环。

while True:
    a = input("请输入一个字符(输入 Q 或 q 结束)")
    if a.upper() == 'Q':
        print("循环结束，退出")
        break
    else:
        print(a)

continue

与 break 语句对应的还有另一个 continue 语句，与 break 语句不同的是，continue 用于 结束本次循环，继续下一次。 多个循环嵌套时，continue 也是应用于最近的一层循环。而 break 语句用来彻底退出循环。

# for 循环来遍历 10 以内的奇数
for i in range(1, 10):
    if i % 2 == 0:
        continue
    else:
        print(i, end='\t')

三元条件运算符

num=int(input('请输入一个整数:'))
print(type(num) if num<10 else '整数过大')

内建数据结构

列表

range()创建整数列表

a=list(range(3,15,2)) #从 3 开始步长是 2 及从开始每次增加 2
b=list(range(15,3,-1)) #从 15 开始每次减 1
c=list(range(3,-10,-1)) #从 3 开始每次递减 1
print(a)
print(b)
print(c)

推导式生成列表

a = [x for x in range(1, 5)]
b = [x * 2 for x in range(1, 5)]
c = [x * 2 for x in range(1, 20) if x % 5 == 0]
d = [x for x in "abcdefg"]
print("a 列表的元素:", a)
print("b 列表的元素:", b)
print("c 列表的元素:", c)
print("d 列表的元素:", d)

列表的添加

在列表的末尾追加一个新对象，使用 append()方法。

# 列表中添加元素
a = [10, 20, 30]
a.append(40)
print('增加元素后的列表：', a)

使用 extend()将目标列表的所有元素添加到本列表的尾部

# 使用 extend()方法添加列表
a = [10, 20, 30]
print('a 的地址：', id(a))
b = [40, 50]
a.extend(b)
print('a 列表的元素：', a)
print('a 的地址：', id(a))

使用 insert()实现列表插入元素

# 使用 insert 函数插入元素
a = [10, 20, 30]
a.insert(2, 100)  # 在列表 a 的索引 2 处插入元素 100
print(a)

列表的查找

通过索引直接访问元素

a = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print("列表中的第一个元素:", a[0])
print("列表中的第三个元素：", a[2])
print("列表中倒数第一个元素:", a[-1])
print("列表中倒数第三个元素：", a[-3])

index()获得指定元素在列表中首次出现的索引

a = [10, 20, 30, 40, 50, 20, 30, 20, 30]
print(a.index(20))  # 从列表中搜索第一个 20
print(a.index(20, 3))  # 从索引位置 3 开始往后搜索的第一个 20
print(a.index(30, 5, 7))  # 从索引位置 5 到 7 这个区间，第一次出现30元素的位置

列表的修改

s = ['admin', 'lili', 'john']
s[0] = '管理员'
print('修改后列表的元素：', s)

列表的删除

a) del 删除，del 删除列表指定位置的元素。语法格式：del 元素。

a=[1,2,3,4,5,6]
del a[2]
print("删除后列表的元素:",a)

b) pop 删除，pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素。

a = [1, 2, 3, 4, 5, 6]
b = a.pop()  # 没有指定位置，默认的是最后一个元素
print(b)
print(a)
c = a.pop(2)  # 删除下标为 2 的元素
print(c)
print(a)

c) remove 删除，删除首次出现的指定元素，若不存在该元素抛出异常。

a = [10, 20, 30, 40, 50, 20, 30, 20, 30]
a.remove(20)
print(a)
a.remove(100)  # 没有 100 这个元素，会抛出异常

列表的乘法

a = ['sxt', 100]
b = a * 3
print(a)
print(b)

列表的长度、最大值和最小值

a = [10, 20, 30, 40, 50, 60]
print(len(a))  # 运行结果是 6
print(max(a))  # 运行结果是 60
print(min(a))  # 运行结果是 10
b = ['a', 30, 'b', 40]
print(max(b))  # 字符串和数字不能比较，将抛出异常

列表的切片操作

a = [10, 20, 30, 40, 50, 60, 70]
print(a[:])  # 默认从列表的开始到列表结束 ，步长为 1
print(a[1:])  # 从列表的索引 1 开始到结束，步长为 1
print(a[:2])  # 从开始到索引 1，步长为 1
print(a[1:3])  # 从列表索引 1 开始到索引 2，步长为 1
print(a[1:6:2])  # 从列表索引 1 开始到索引 5，步长为 2
print(a[-3:])  # 从列表的倒数第 3 个开始到列表结束
print(a[-5:-3])  # 从倒数第 5 个开始到倒数第 4 个
print(a[::-1])  # 从右到左反向提取

常用方法

# copy()进行复制列表
aa = ['a', 'b', 'c']
bb = aa.copy()
print(aa)
print(bb)

# count()统计元素出现的次数
a = [10, 20, 40, 30, 10, 20, 50, 10]
print('元素 10 出现的次数：', a.count(10))
print('元素 20 出现的次数：', a.count(20))
print('元素 30 出现的次数：', a.count(30))

# reverse()用于将列表中的元素反向存放
a = [1, 2, 3, 4, 5, 6, 7]
a.reverse()
print(a)

# sort()用于对列表进行排序，调用该方法会改变原来的列表
a = [11, 20, 13, 34, 5, 36, 17]
a.sort()
print(a)
print('正序：', a)
a.sort(reverse=True)
print('逆序：', a)
# sorted 用于对列表进行排序，生成新列表，不改变原来的列表
print('-' * 5, 'sorted 排序', '-' * 5)
a = [11, 20, 13, 34, 5, 36, 17]
b = sorted(a)
print('a 列表：', a)  # 原来列表不会被修改
print('正序 b 列表：', b)
b = sorted(a, reverse=True)
print('逆序 b 列表：', b)

# clear()用于清空列表内容
a = [11, 20, 13, 'a', True, 'hello']
print(a)
a.clear()
print(a)

列表遍历

for 循环遍历列表

# for 循环遍历列表
my_list = ["a", "b", "c", "d"]
for value in my_list:
    print(value)

while 循环遍历列表

# while 循环遍历列表
my_list = ["a", "b", "c", "d"]
# 定义变量
index = 0
# 定义变量 记录列表元素个数
l = len(my_list)
while index < l:
    # 通过下标索引获取元素
    value = my_list[index]
    print(value)
    index += 1

二维列表

a = [
    ["高小一", 18, 30000, "北京"],
    ["高小二", 19, 20000, "上海"],
    ["高小一", 20, 10000, "深圳"],
    ]
for m in range(3):
    for n in range(4):
        print(a[m][n], end="\t")
    print()  # 打印完一行，换行

元组

元组的创建

1)通过()创建元组，小括号可以省略。

# 通过()创建元组
a = 1, 2, 3, 4, 5, 6, 7  # 创建一个元组 省略了括号
b = (1, 2, 3, 4, 5, 6, 7)  # 创建一个元组
c = (42,)  # 创建一个只有一个元素值的元组
d = ()  # 创建一个空的元组
print(a)
print(b)
print(c)
print(d)

2)通过 tuple()创建元组

# 使用 tuple()函数创建元组
a = tuple("abc")
b = tuple(range(3))
c = tuple((1, 2, 3, 4, 5))
print(a)
print(b)
print(c)

3)生成器推导式创建元组

# 生成器的使用
s = (x * 2 for x in range(5))
print(s)  # 生成器对象
print(tuple(s))  # tuple 函数转换为元组
print(tuple(s))  # 只能访问一次元素。第二次就为空了。需要再生成一次
s = (x * 2 for x in range(5))
print('next 方法获取元素：', s.__next__())
print('next 方法获取元素：', s.__next__())
print('next 方法获取元素：', s.__next__())
print('next 方法获取元素：', s.__next__())
print('next 方法获取元素：', s.__next__())
print('next 方法获取元素：', s.__next__())  # 已经没有元素了

元组的元素不能修改

a = (20, 10, 30, 9, 8)
a[3] = 33  # 修改元组中的元素

元组的切片

a = (20, 10, 30, 9, 8)
print(a[1])
print(a[1:3])
print(a[:4])

元组的排序

a = (20, 10, 30, 9, 8)
print(sorted(a))

字典

字典的创建

1)通过{}、dict()来创建字典对象

a = {'name': 'gaoqi', 'age': 18, 'job': 'programmer'}
b = dict(name='gaoqi', age=18, job='programmer')
c = dict([("name", "gaoqi"), ("age", 18), ("job", 'programmer')])
d = {}  # 空的字典对象
e = dict()  # 空的字典对象
print('字典 a：', a)
print('字典 b：', b)
print('字典 c：', c)
print('字典 d：', d)
print('字典 e：', e)

2)通过 zip()创建字典对象

k = ['name', 'age', 'job']
v = ['gaoqi', 18, 'techer']
a = dict(zip(k, v))
print('字典 a：', a)

3)通过 fromkeys 创建值为空的字典

a = dict.fromkeys(['name', 'age', 'job'])
print('值为空的字典 a:', a)

字典的访问

1)通过 [键]获得“值”

a = {'name': 'gaoqi', 'age': 18, 'job': 'programmer'}
print('name:', a['name'])
print('age:', a['age'])
print('job:', a['job'])

2)get 方法获取 key 对应的 value

a = {'name': 'gaoqi', 'age': 18, 'job': 'programmer'}
print('name:', a.get('name'))
print('age:', a.get('age'))
print('job:', a.get('job'))
print('sex:', a.get('sex'))

字典的常用操作

1)字典添加、修改元素操作

a = {'name': 'gaoqi', 'age': 18, 'job': 'programmer'}
a['address'] = '北京'  # address 的键不存在，则新增
a['age'] = 28  # age 的键存在，则进行修改
print(a)

2)字典 update 方法的使用

update 方法可以用一个字典中的元素更新另外一个字典。该方法接收一个参数。该参数

表示用作更新数据的字典数据源。如果 key 有重复，则直接覆盖。

a = {'name': 'gaoqi', 'age': 18, 'job': 'programmer'}
b = {'name': 'gaoxixi', 'money': 1000, 'sex': '男的'}
a.update(b)
print(a)

3)字典使用 del()删除元素

a = {'name': 'gaoqi', 'age': 18, 'job': 'programmer'}
del (a['name'])  # del 删除元素
print(a)
b = a.pop('age')  # pop 删除元素，返回对应的值
print(b)
print(a)
a.clear()  # 清空字典元素
print(a)

4)字典使用 popitem()删除元素

popitem()方法用于随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念；popitem 弹出随机的项，因为字典并没有"最后的元素"或 者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效(因为不用 首先获取键的列表)。

a = {'name': 'gaoqi', 'age': 18, 'job': 'programmer'}
print(a.popitem())
print(a.popitem())
print(a.popitem())

items 方法、keys 方法和 values 方法

items 方法用于返回字典中所有的 key-value 对。获得的每一个 key-value 对用一个元组表示。items 方法返回的值是一个被称为字典视图的特殊类型，可以被用于迭代(如使用在 for 循环中)。items 方法的返回值与字典使用了同样的值，也就是说，修改了字典或 items 方法的返回值，修改的结果就会反应在另一方法上。keys 方法用于返回字典中所有的 key， 返回值类型与 items 方法类似，可以用于迭代。values 方法用于以迭代器形式返回字典中值 的列表。

a = {'name': 'gaoqi', 'age': 18, 'job': 'programmer'}
print(a.items())  # 字典中所有的 key-value 对
print(a.keys())  # 字典中所有的 keys
print(a.values())  # 字典中所有的 value
# 通过遍历 key，根据 key 获取值
for key in a.keys():
    print(key, ':', a.get(key))
for i in a.items():
    print(i)

序列解包

x, y, z = (20, 30, 10)
print('x:', x)
print('y:', y)
print('z:', z)
(a, b, c) = (9, 8, 10)
print('a:', a)
print('b:', b)
print('c:', c)
[a, b] = ['hello', 'python']
print('a:', a)
print('b:', b)

字典实现存储表格数据

r1 = {"name": "高小一", "age": 18, "salary": 30000, "city": "北京"}
r2 = {"name": "高小二", "age": 19, "salary": 20000, "city": "上海"}
r3 = {"name": "高小五", "age": 20, "salary": 10000, "city": "深圳"}
tb = [r1, r2, r3]
# 获得第二行的人的薪资
print(tb[1].get("salary"))
print('====================')
# 打印表中所有的的薪资
for i in range(len(tb)):  # i -->0,1,2
    print(tb[i].get("salary"))
# 打印表的所有数据
for i in range(len(tb)):
    print(tb[i].get("name"), tb[i].get("age"), tb[i].get("salary"), tb[i].get("city"))

集合

集合创建

1)使用{}创建集合对象

a = {3, 5, 7}  # 集合存储整数
b = {'hello', 'python'}  # 集合存储字符串
c = {3, 4, True, 'abc', 56.4}  # 集合存储不同类型的数据
print(a)
print(b)
print(c)

2)使用 set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保留一个。

a = ['a', 'b', 'c', 'b']
b = set(a)  # 将列表转换为集合
print(b)
c = (1, 2, 3, 4, 5)
d = set(c)  # 将元组转换为集合
print(d)

集合添加

a = {3, 5, 7}
a.add('hello')  # add 方法添加元素
print(a)

集合删除

a = {10, 20, 30, 40, 50}
a.remove(20)  # 删除集合中的元素
print(a)
a.clear()  # 将集合清空
print(a)

集合交并差运算

a = {1, 3, 'sxt'}
b = {'he', 'it', 'sxt'}
print('并集：', a | b)  # 并集
print('并集：', a.union(b))  # 并集
print('交集：', a & b)  # 交集
print('交集：', a.intersection(b))  # 交集
print('差集：', a - b)  # 差集
print('差集：', a.difference(b))

enumerate() 函数

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for 循环中。

seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
    print(i, element)

zip

zip(列表 1，列表 2，...)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象。

# zip合并元组
a = [10, 20, 30]
b = [40, 50, 60]
c = [70, 80, 90]
d = zip(a, b, c)
print(d)   # zip对象
print(list(d))