学习笔记"/>
走进python三千章,自信人生二百年——python学习笔记
python 学习笔记
一、 print语句
1.可以输出数字
print(666)
2.可以输出字符串
print('right')
print("right")
3.含有运算符的表达式,且会计算表达式的结果
print(6 + 6)
*4.将数据输出文件中 1.注意所指定的盘符存在 2.使用file=fp,否则会读成a,数据会无法进入
fp = open('D:/text.txt', 'a+') # “a+”表示若没有文件则新建文件,存在就在文件内容的后面继续输出
print('少 年 何 妨 梦 摘 星,敢 挽 桑 弓 射 玉 衡 !', f1ile=fp)
fp.close()
5.不进行换行输出(输出内容在一行当中)
print('Hello', 'My', 'Python')
6.语句换行
print("少 年 何 妨 梦 摘 星\敢 挽 桑 弓 射 玉 衡")
二、语句注释
"
""
print("少 年 何 妨 梦 摘 星\敢 挽 桑 弓 射 玉 衡")
"""
''''''print("少 年 何 妨 梦 摘 星\敢 挽 桑 弓 射 玉 衡")'''
三、 缩进(不可用TAB键,应使用空格键完成操作)
if True:print("如果为真,输出:")print("true")
else:print("否则,输出:")print("false")
四、数据类型
1.数字类型(number)
整型(int)可以用二进制-
浮点型(float)
复数型(complex)
布尔型(bool) 布尔型是一种比较特殊的整型,它只有True和False两种值,分别对应1和0,它主要用来比较 和判断,所得结果叫做布尔值。
2.字符串类型(String)
3.列表类型(List)
4.元组类型(Tuple)
5.字典类型(Dict)(Dictionary)
6.集合类型(Set)
7.检测数据类型Python中内置了检测数据类型的函数type()。它可以对不同类型的数据进行检测
d = 10
print(type(d))
8.除此之外,还可以使用函数isinstance()判断数据是否属于某个类型
print(isinstance(d, int))
print(isinstance(d, float))
9. python常见关键词
关键字 | 描述 |
---|---|
and | 逻辑运算符 |
as | 创建别名 |
assert | 用于调试 |
break | 跳出循环 |
class | 定义类 |
continue | 继续循环的下一个迭代 |
def | 定义函数 |
del | 删除对象 |
elif | 在条件语句中使用,等同于 else if |
else | 用于条件语句 |
except | 处理异常,发生异常时如何执行 |
False | 布尔值,比较运算的结果 |
finally | 处理异常,无论是否存在异常,都将执行一段代码 |
for | 创建 for 循环 |
from | 导入模块的特定部分 |
global | 声明全局变量 |
if | 写一个条件语句 |
import | 导入模块 |
in | 检查列表、元组等集合中是否存在某个值 |
is | 测试两个变量是否相等 |
lambda | 创建匿名函数 |
None | 表示 null 值 |
nonlocal | 声明非局部变量 |
not | 逻辑运算符 |
or | 逻辑运算符 |
pass | null 语句,一条什么都不做的语句 |
raise | 产生异常 |
return | 退出函数并返回值 |
True | 布尔值,比较运算的结果。 |
try | 编写 try…except 语句 |
while | 创建 while 循环 |
with | 用于简化异常处理 |
yield | 结束函数,返回生成器 |
seed() | 初始化随机数生成器 |
getstate() | 返回随机数生成器的当前内部状态 |
setstate() | 恢复随机数生成器的内部状态 |
getrandbits() | 返回表示随机位的数字 |
randrange() | 返回给定范围之间的随机数 |
randint() | 返回给定范围之间的随机数 |
choice() | 返回给定序列中的随机元素 |
choices() | 返回一个列表,其中包含给定序列中的随机选择 |
shuffle() | 接受一个序列,并以随机顺序返回此序列 |
sample() | 返回序列的给定样本 |
random() | 返回 0 与 1 之间的浮点数 |
uniform() | 返回两个给定参数之间的随机浮点数 |
triangular() | 返回两个给定参数之间的随机浮点数,您还可以设置模式参数以指定其他两个参数之间的中点 |
betavariate() | 基于 Beta 分布(用于统计学)返回 0 到 1 之间的随机浮点数 |
expovariate() | 基于指数分布(用于统计学),返回 0 到 1 之间的随机浮点数,如果参数为负,则返回 0 到 -1 之间的随机浮点数。 |
gammavariate() | 基于 Gamma 分布(用于统计学)返回 0 到 1 之间的随机浮点数 |
gauss() | 基于高斯分布(用于概率论)返回 0 到 1 之间的随机浮点数 |
lognormvariate() | 基于对数正态分布(用于概率论)返回 0 到 1 之间的随机浮点数 |
normalvariate() | 基于正态分布(用于概率论)返回 0 到 1 之间的随机浮点数 |
vonmisesvariate() | 基于 von Mises 分布(用于定向统计学)返回 0 到 1 之间的随机浮点数 |
paretovariate() | 基于 Pareto 分布(用于概率论)返回 0 到 1 之间的随机浮点数 |
weibullvariate() | 基于 Weibull 分布(用于统计学)返回 0 到 1 之间的随机浮点数。 |
五、运算符
1.常用运算符
运算符 | 描述 | 示例 |
---|---|---|
+ | 相加 | a + b |
- | 相减 | a - b |
* | 相乘 | a * b |
/ | 相除 | a / b |
% | 取模 | a % b |
** | 幂 | a**b 表示 a 的 b 次幂 |
// | 取整 | 9 // 4 结果为 2 |
== | 是否相等 | a == b |
!= | 是否不等于 | a != b |
> | 是否大于 | a > b |
>= | 是否大于等于 | a >= b |
<= | 是否小于等于 | a <= b |
= | 简单的赋值运算符 | a = b + c |
+= | 加法赋值运算符 | a += b 等效于 a = a + b |
-= | 减法赋值运算符 | a -= b 等效于 a = a - b |
*= | 乘法赋值运算符 | a *= b 等效于 a = a * b |
/= | 除法赋值运算符 | a /= b 等效于 a = a / b |
%= | 取模赋值运算符 | a %= b 等效于 a = a % b |
**= | 幂赋值运算符 | a** = b 等效于 a = a** b |
//= | 取整除赋值运算符 | a //= b 等效于 a = a // b |
& | 与 | a & b |
| | 或 | a | b |
^ | 异或 | a ^ b |
~ | 取反 | ~a |
<< | 左移动 | a << 3 |
>> | 右移动 | a >> 3 |
and | 布尔类型与 | a and b |
or | 布尔类型或 | a or b |
not | 布尔类型非 | not a |
is | 判断两个标识符是否引用同一个对象 | a is b |
is not | 判断两个标识符是否引用不同对象 | a is not b |
2. 运算符优先级
运算符 | 描述(由上至下对应优先级由高到低) |
---|---|
** | 幂运算 |
~ + - | 取反、正号、负号 |
* / % // | 乘、除、取模、取整除 |
+ - | 加法、减法 |
>> << | 右移、左移 |
& | 与 |
^ | | 异或、或 |
<= < > >= | 比较运算符 |
== != | 是否等于、是否不等于 |
= % = / = // = -= += *= **= | 赋值运算符 |
is is not | 身份运算符 |
in not in | 成员运算符 |
not and or | 逻辑运算符 |
3、赋值运算符的使用
a, b = 5, 2
a += b
print(a, b)
a -= b
print(a, b)
a *= b
print(a, b)
a /= b
print(a, b)
a **= b
print(a, b)
a //= b
print(a, b)
4、比较运算符的使用
print(1 == 1)
print(1 == 2)
print(1 == True)
print(0 == False)
print(1.0 == True)
print(0.0 == False)
print((0.0 + 0.0j) == False)
5、逻辑运算符的使用
print(0 and 4)
print(False and 4)
print(1 and 4)
print(1 or 4)
print(True or 4)
print(0 or 4)
print((4 <= 5) and (4 >= 3))
print((4 >= 5) or (4 <= 3))
print(not 1)
6、位运算符的使用
a, b = 7, 8
print(bin(a)) # 二进制形式111
print(bin(b)) # 二进制形式1000
print(bin(a & b))
print(bin(a | b))
print(bin(a ^ b))
print(bin(~a))
print(bin(a << 2))
print(bin(a >> 2))
7、成员运算符的使用
A = [1, 2, 3, 4] # 列表
print(1 in A)
print(0 in A)
print(1 not in A)
print(0 not in A)
8、身份运算符的使用
a: int
a = b = 10 # a,b都为10
print(a is b)
print(a is not b)
b = 20 # b修改为20
print(a is b)
print(a is not b)
9、小案例
从键盘输入一个3位整数,计算并输出其百位、十位和个位上的数字,程序运行时,从键盘输入356
x = int(input("请输入一个三位整数:"))
g = x // 1 % 10 # 个位数
s = x // 10 % 10 # 十位数
b = x // 100 % 10 # 百位数
print('百位:', b, '十位:', s, '个位:', g)
六.顺序结构
1.对象的布尔值
以下对象的布尔值为False
*Flase
*数值()
*None
*空字符串
*空列表
*空元组
*空字典
*空集合
其他对象的bool值均为True
print('-------------------------------------------')
print(bool(False)) # False
print(bool(0)) # False
print(bool(0.0)) # False
print(bool(None)) # False
print(bool('')) # False
print(bool("")) # False
print(bool([])) # 空列表
print(bool(list())) # 空列表
print(bool(tuple())) # 空元组
print(bool({})) # 空字典
print(bool(dict())) # 空字典
print(bool(set())) # 空集合
print('-----------以上对象的布尔值为False--------------')
七、条件语句
1.if语句
‘’’
if语句用于在程序中有条件地执行某些语句,格式如下:
if条件表达式:
语句块#当条件表达式为True时,执行语句块
‘’’
1.1 if 语句用法
score = 90
if score >= 60:print("优秀!")
print("您的分数%d" % score)
2.if-else语句
if-else语句用于根据条件表达式的值决定执行那块代码,其语法格式如下:
if条件表达式:
语句块 1 # 当条件表达式为True时,执行语句块1
else:
语句块 2 # 当条件表达式为False时,执行语句块2
2.1 if-else 语句用法
score = 80
if score >= 60:print("优秀")
else:print("加油!")print("您的分数为:%d" % score)
3.if-elif 语句
‘’’
在程序中多重判断可以通过 if-elif 语句实现,其语法格式如下 :
if 条件表达式1:
语句块 1 #当条件表达式1为True时,执行语句块1
elif 条件表达式2:
语句块 2 #当条件表达式2为True时,执行语句块2
…
elif 条件表达式n:
语句块 n #当条件表达式n为True时,执行语句块n
‘’’
3.1 if—elif语句用法
score = 80
if 90 <= score <= 100:print("成绩爆表")
elif 80 <= score < 90:print("成绩优秀")
elif 60 <= score < 80:print("成绩合格")
elif 0 <= score < 60:print("成绩堪忧")
print("您的成绩为:%d" % score)
4. if-elif-else 语句
‘’’
此外 if-elif 语句后还可以使用 else语句
用来表示if-elif语句中有条件不满足时执行的语句块,其语法格式如下
if 条件表达式1:
语句块 1 #当条件表达式1为True时,执行语句块1
elif 条件表达式2:
语句块 2 #当条件表达式2为True时,执行语句块2
…
else 条件表达式n:
语句块 n #当以上条件表达式均为False时,执行语句块n
‘’’
4.1 if-elif-else语句的使用
score = 120
if 90 <= score <= 100:print("成绩爆表")
elif 80 <= score < 90:print("成绩优秀")
elif 60 <= score < 80:print("成绩合格")
elif 0 <= score < 60:print("成绩堪忧")
else:print("成绩有误")
print("您的成绩为:%d" % score)
5 if 语句嵌套
‘’’
if 语句嵌套是指if、if-else中的语句块可以是if或if-else语句,其语法格式如下:
(一) if 语句
if 条件表达式1:
if 条件表达式2: #嵌套if语句
语句块2
if 条件表达式3: #嵌套if-else语句
语句块3
else:
语句块4
(二) if-else语句
if 条件表达式1:
if 条件表达式2: #嵌套if语句
语句块2
else:
if 条件表达式3: #嵌套if-else语句
语句块3
else:
语句块4
‘’’
5.1 if嵌套语句的用法
a, b, c = 5, 8, 3
if a >= b:if a >= c:print("a,b,c中最大的值为:%d" % a)else:print("a,b,c中最大的值为:%d" % c)
else:if b >= c:print("a,b,c中最大的值为:%d" % b)else:print("a,b,c中最大的值为:%d" % c)
八、循环语句
1.内置函数range()
当遍历数字序列时,可以使用range()函数
(1)第一种创建方式,只有一个参数(小括号中只给了一个数)
r = range(10) # [0,1,2,3,4,5,6,7,8,9],默认为从0开始,默认相差1称为步长
print(r) # range(0,10)
print(list(r)) # 用于查看range对象中的整数序列 ———>list是列表的意思
(2)第二种创建方式,给了两个参数(小括号中给了两个数)
r = range(1, 10) # 指定了起始值,从1开始,到10结束(不包括10),默认步长为1
print(list(r)) # [1,2,3,4,5,6,7,8,9]
(3)第三种创建方式,给了三个参数(小括号中给了三个数)
r = range(1, 10, 2)
print(list(r)) # [1,3,5,7,9]
(4)判断指定的整数在序列中是否存在 in,not in
print(10 in r) # False,10不在当前的r这个整数序列中
print(9 in r) # True, 9在当前的r这个整数序列中
print(10 not in r) # True
print(9 not in r) # False
sum = 0
for i in range(1, 101):sum += 1print("1 + 2 + ··· + 100 = %d" % sum)
2.while语句
‘’’
在while语句中,当条件表达式为True时,就重复执行语句块;当条件表达式为False时,就结束执行语句块。while语句的语法格式如下:
While条件表达式:
语句块 # 此处语句块也称循环体
‘’’
while语句的用法
i, sum = 1, 0 # 实现1~100的累加
while i < 101:sum += 1i += 1print("1 + 2 + ··· + 100 = %d" % sum)
3.for语句
for语句的用法:
for word in "python":print(word)
4.while与for嵌套
(1) while语句中嵌套while语句 九九乘法表
i = 1
while i < 10:j = 1while j <= i:print("%d*%d=%-3d" % (i, j, i * j), end='')j += 1i += 1print(end='\n')
(2) while语句中嵌套for语句 九九乘法表
i = 1
while i < 10:for j in range(1, i + 1):print("%d*%d=%-3d" % (i, j, i * j), end='')i += 1print(end='\n')
(3)for语句中嵌套while语句 九九乘法表
for i in range(1, 10):j = 1while j <= i:print("%d*%d=%-3d" % (i, j, i * j), end='')j += 1print(end='\n')
(4) for语句中嵌套for语句 九九乘法表
for i in range(1, 10):for j in range(1, i + 1):print("%d*%d=%-3d" % (i, j, i * j), end='')print(end='\n')
5.break语句
break语句可以使程序立即退出循环,转而执行该循环的下一条语句。
如果break语句出现在嵌套循环中的内层循环中,则break语句只会跳出当前层的循环。
i = 0
while True:i += 1print("第%d次循环开始" % i)if i == 3:breakprint("第%d此循环结束" % i)print("整个循环结束")
6.continue语句
i = 0
while i < 3:i += 1print("第%d次循环开始" % i)if i == 2:continueprint("第%d次循环结束" % i)
print("整个循环结束")
7. else语句
‘’’
else语句除了可以与if语句搭配使用外,还可以与while语句,for语句搭配使用,
当条件不满足时执行else语句块,它只在循环结束后执行。
‘’’
(1)for语句搭配else语句的用法
for n in range(1, 3):print("第%d次循环" % n)
else:print("循环结束")
(2) for语句中存在break语句
for n in range(1, 4):print("第%d次循环" % n)if n == 2:breakelse:print("循环结束")
print("程序结束")
8.pass语句
for n in range(1, 3):passprint("暂时没有思路")
print("程序结束")
练习:程序输出1~100的质数
print('以下是100以内的质数:')
for num in range(2, 101): # ramge函数生成2~100之间的整数,使用for语句遍历这些整数,if all(num % i != 0 for i in range(2, num)): # 对每个整数进行判断是否是质数,print(num) # (仅能被1和自身整除的整数),使用all()函数和一个生成器表达式进行判断,# 如果一个数能被2到(n-1)之间的任意数整除,则返回False,否则返回True,最后如果这个数是质数则将这个数输出sum=0
sum = 0
for i in range(2, 100): # 循环迭代i 2->100for j in range(2, i): # 第二次循环迭代j 2->i-,判断i 是否能被j整除if i % j == 0: # 如果i能被j整除,说明i不是质数,跳出循环breakelse: # 如果第二层for循环正常结束,说明i为质数,将它加到sum上sum += i
print("100以内质数的和为:", sum) # 输出质数之和
九、字符串
1. 使用单引号标识字符串
'别让世俗淹没生活的浪漫与热爱 !'
2.使用双引号标识字符串
"别让世俗淹没生活的浪漫与热爱 !"
3. 使用三引号标识字符串
'''
别让世俗淹没生活的浪漫与热爱
'''
"""
别让世俗淹没生活的浪漫与热爱
"""
4. 字符串不可以被修改但是可以被截取
str = "xiaoqian is a programmer."
print(str[0:14] + "gril")
5.、转义字符
1.换行\n
print('Hello\nWord')
2.回车\r
print('Hello\rWord') # word将hello覆盖了
3.水平制表符\t
print('Hello\tWord')
4.退格\b
print('Hello\bWord') # \b是退一格,将o退没了
print('http:\\www.baidu')
print('他说:"别让世俗淹没生活的浪漫与热爱 !"')
5.原字符,不希望转义字符起作用,就是用原子符。在原子符之前加上r或R
print(r'别让世俗淹没生活的浪漫\n与热爱')
6.注意事项,最后一个字符不能是反斜杠
如:
print(r'别让世俗淹没生活的浪漫\n与热爱\')print('r''别让世俗淹没生活的浪漫\n与热爱\')
6.字符串的输出
print("666")
7.常用的格式化符号
格式符号 | 转换 |
---|---|
%s | 格式化字符串 |
%c | 格式化字符 |
%i | 格式化有符号十进制整数 |
%d | 格式化整数 |
%u | 格式化无符号十进制整数 |
%o | 格式化八进制整数 |
%x | 格式化十六进制整数(小写字母) |
%X | 格式化十六进制整数(大写字母) |
%e | 用科学计数法格式化浮点数 |
%E | 作用和%e一样 |
%f | 格式化浮点实数 |
%g | %f和%e的简写 |
%G | %f和%E的简写 |
%% | 输出% |
8.字符串的输入
input("666")
9.字符串的索引与切片
字符串可以通过运算符[]进行索引与切片,字符串中每个字符都对应两个编号(也称下标)字符串str正向编号从0开始,
代表第一个字符,依次往后,字符串str负向编号从-1开始,代表最后一个字符,依次向前。因为编号可正可负,所以字符串中的
某个字符可以有两种方法索引。
str=("cong cong na nian")0123456789
str = "cong cong na nian"
(1)单个字符
print(str[10])
print(str[6]) # 空格也是字符
print(str[66]) # IndexError: string index out of range 字符超出索引范围
print(str[-2])
(2)多个字符切片
print(str[0:4]) # 类似于range()函数的使用,默认步长为1
print(str[:5]) # 等价于str[0:5:1]
print(str[:]) # 整个字符串
print(str[2:4:2]) # 索引2,4两个字符,步长为2
print(str[2:8:-2]) # - 表示反方向取,步长为2,从8开始到2,一般不常用
10.字符串的运算
运算符 | 说明 |
---|---|
+ | 字符串连接 |
* | 重复字符串 |
[] | 索引字符串中的字符 |
[:] | 对字符串进行切片 |
in | 如果字符串中包含给定字符,返回True |
not in | 如果字符串中包含给定字符,返回False |
r或R | 原样使用字符串 |
11.字符串的运算
str1, str2 = "青春的颜色", "一抹绚烂"
print(str1 + str2)
print(3 * (str1 + str2))
if "季节" in "季节更替":print("注意身体!")
else:print("各自安好!")
12.字符串常用函数
(1)大小写转换
函数 | 说明 |
---|---|
upper() | 将字符串中所有小写字母转换为大写 |
lower() | 将字符串中所有大写字母转换为小写 |
capotalize() | 将单词的首字母大写 |
title() | 将每个字符串中单词的首字母大写 |
name = "time"
str = input("请输入用户名(不区分大小写):")
if str.lower() == name:print("欢迎用户%s登录" % name)
else:print("用户名错误!")
(2)判断字符
函数 | 说明 |
---|---|
isupper() | 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写)字符都是大写,则返回True,否则返回False |
islower() | 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写)字符都是小写,则返回True,否则返回False |
isalpha() | 如果字符串至少有一个字符并且所有字符都是字母,则返回True,否则返回False |
isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字,则返回True,否则返回False |
isspace() | 如果字符串中只包含空白,则返回True,否则返回False |
istitle() | 如果字符串是标题化的,则返回True,否则返回False |
八.列表
列表的概念:列表是python以及其他语言中最常用的数据类型之一。python中常用括号[]来创建列表
‘’
student = [20190101, “李四”, 18, 99.5]
(1)列表的创建
‘’’
列表是由一组任意类型的值组合而成的序列,组成列表的值称为元素,每个元素之间用逗号隔开,具体示例如下:‘’’
list1 = [1, 2, 3, 4, 5] # 元素为int型
list2 = ['你好', '我的世界', '!'] # 元素为string型
list3 = ['李四', 18, 99.5] # 元素为混合型
list4 = ['你好', ['张三', 18, 99.5]] # 列表嵌套列表
'''此外还可以创建一个空列表'''
list5 = [] # 空列表
(2) # 列表的简单使用
name, age, score = '小千', 98.5
list1 = [name, age, score]
print(list1)
name, age, score = '小峰', 20, 100
print(list1)
print(name, age, score)
list1[0] = name
print(list1)
(3)list()函数的用法
list1 = list("qianfeng")
list2 = list(range(1, 5))
list3 = list(range(5))
list4 = list(range(1, 5, 2))
print(list1)
print(list2)
print(list3)
print(list4)
range()函数 | |
---|---|
range(start,end) | 返回一系列整数从start开始,到end-1结束,相邻两个整数差1 |
range(end) | 返回一系列整数从0开始,到end-1结束,相邻两个整数差1 |
rnage(start,end,step) | 返回一系列整数从start开始,相邻两个整数差step,结束整数不超过end-1 |
(4)列表的索引
list1 = [1, 2, 3, 4, 5, 6, 7, 8]
list1[4]
list1[-4]
(5)列表的切片
list1 = [1, 2, 3, 4, 5, 6, 7, 8]
print(list1[2:6])
print(list1[2:6:2])
print(list1[:6])
print(list1[2:])
print(list1[-6:-2])
print(list1[-6:-2:2])
print(list1[::-2])
(6)列表的遍历
‘’’
1、通过while循环遍历列表
通过while循环遍历列表,需要使用len()函数,该函数可以获取序列中元素的个数
print(len('helloword')) # 9
list = [1, 2, 3, 4] # 4
print(len(list))lsit = ['青春', '短暂', '需珍惜']
length, i = len(list), 0
while i < length:print(list[i])i += 1
2.通过for循环遍历列表
只需将列表名放在for语句中in关键词之后
list = ['青春', '短暂', '需珍惜']
for value in list:print(value)
(7) 列表的运算
运算符 | 说明 |
---|---|
+ | 列表连接 |
* | 重复列表元素 |
[ ] | 索引列表中的字符 |
[ : ] | 对列表行切片 |
in | 如果列表中包含给定元素,返回True |
not in | 如果列表中包含给定元素,返回False |
list1, list2 = ['青春', '短暂'], ['需珍惜']
print(3 * list2)
print(list1 + list2)
print("短暂" in list2)
print("青春" in list1)
name1, name2 = list1[0:]
name3, neme4 = list1
print(name1, name2, name3, name4)
(8)修改元素
修改列表中的元素只需索引需要修改的元素并对其赋新值即可
list1, list2 = ['青春', '短暂', '需珍惜'], ['!!!']
list1[0], list[1] = 'www.baidu,com', 'www.qq'
print(list1)
list1[1:] = list2[0:2]
print(list1)
(9)添加元素
函数 | 说明 |
---|---|
append(obj) | 在列表末尾添加元素obj |
extend(seq) | 在列表末尾一次性添加另一个序列seq中的多个元素 |
insert(inddex,obj) | 在元素obj插入列表的index位置处 |
lis1, lis2 = ['青春'], ['别留遗憾']
lis1.append('短暂')
print(lis1)
lis1.extend(lis2)
print(lis1)
lis2.insert(1, '!')
print(lis2)
(10) 删除元素
删除函数
函数 | 说明 |
---|---|
pop(index=-1) | 删除列表中index处的元素(默认的为index=-1).并返回该元素的值 |
remove(obj) | 删除列表中第一次出现的obj元素 |
clear( ) | 删除(清空)列表中的所有元素,(不释放内存空间) |
del( ) | 用del[索引数] 函数删除指定索引数的元素 或删除整个变量(将元素完全删除,并释放内存空间,且不可恢复) |
复制函数
copy() | 将当前的列表复制一份相同的列表,新列表与旧列表内容相同,但内存空间不同 |
---|
# 在列表中删除与复制元素
lis3 = ['缘分', '随遇', '而安', '即可']
lit1 = lis3.pop()
print(lis3, lit1)
lit1 = lis3.pop(2)
print(lis3, lit1)
lis3.append('!!!')
print(lis3)
lis3.remove('!!!')
print(lis3)
lis3.clear()
print(lis3)
lit2 = ['春风', '不解风情', '吹动', '少年', '的心']
lis3.extend(lit2)
print(lis3)
del lis3[1]
print(lis3)
lit3 = lis3.copy()
print(lit3)
(11)查找元素位置
index()函数可以从列表中查找出某个元素第一次出现的位置,其中obj表示需要查找的元素,start表示查找范围的起始处,end表示查找范围的结束处(不包括该处)。
其语法格式如下
index(obj,start=0,end=-1)
# 查找列表中元素的值
list2 = ['教育', '学堂', '程序员', '学堂']
print(list2.index('学堂'))
print(list2.index('学堂', 2))
print(list2.index('学堂', 1, 3))
print(list2[2:-1])
(12) 元素排序
如果需要对列表中的元素进行排序,则可以使用sort()函数对列表操作时,reverse()函数可以将列表中的元素反转(也称为逆序)
list3 = [5, 9, 4, 7, 1, 8, 2]
list3.sort()
print(list3)
list3.sort(reverse=True)
print(list3)list4 = ['教育', '学堂', '程序员']
list4.reverse()
print(list4)
(13)统计元素个数
count()函数可以统计列表中某个元素的个数
list4 = ['教育', '学堂', '程序员', '学堂']
print(list4.count('学堂'))
(14)列表推导式
[表达式1 for k in L if 表达式2]
等价于:
list=[]
for k in L :if 表达式2:list.append(表达式1)
l1 = sum([n for n in range(1, 101) if n % 2 != 0])
print(l1)
lit4 = ['春风', '不解风情', '吹动', '少年', '的心']
lit5 = [l for l in lit4 for i in range(2)]
print(lit5)
九、元组
元组与列表类似,也是一种序列,不同之处在于元组中元素不能被改变,并且使用小括号中的一系列元素
(1)元组的创建
创建元组的语法非常简单,只需用逗号将元素隔开
tuple1 = (1, 2, 3, 4)
tuple2 = ('青春', 18, 100)
tuple3 = () # 创建空元组
tuple4 = (1,) # 创建只有一个元素的元组 注意此处逗号必须添加,如果省略,则相当于 在一个普通括号内输入了一个值。此处添加逗号后,就通知解释器,这是一个元组
(2) 元组的索引
元组可以使用下标索引来访问元组中的一个元素,也可以使用切片访问多个元素
注意不能通过下标索引修改元组中的元素,因为元组中元素不能被修改。
(3)元组的遍历
元组的遍历与列表的遍历类似,都可以通过for循环实现
# for循环tuple5 = ('春风', '不解风情', '吹动', '少年', '的心')
for name in tuple5:print(name)# while 循环k, cd = 0, len(tuple5)
while k < cd:print(tuple5[k], end=' ')k += 1
(4) 元组的运算
运算符 | 说明 |
---|---|
+ | 元组连接 |
* | 重复元组元素 |
[ ] | 索引元组中的字符 |
[ : ] | 对元组行切片 |
in | 如果元组中包含给定元素,返回True |
not in | 如果元组中包含给定元素,返回False |
(5)元组与列表转换
list()函数可以将元组转换为列表,而tuple()函数可以将列表转换为元组
tuple6 = ('春风', '不解风情', '吹动', '少年', '的心')
list6 = list(tuple6)
print(list6)
tuple7 = tuple(list6)
print(tuple7)
(6)元组的修改
不可直接修改,可将需要修改的元组转换为列表,通过修改列表的方法修改,完成后再转换回元组
练习:1.六位评委打分,去除最低分和最高分 平均成绩为最终成绩
df = [] # 创建空列表用以储存数据
for i in range(1, 7): # 对六位评委输入成绩进行遍历num = float(input('%d号评委打分:' % i))df.append(num) # 将得分添加到列表中
min = min(df) # 找到列表中得最大值
max = max(df) # 找到列表中得最小值
df.remove(min) # 去除最小值
df.remove(max)
a = sum(df) / len(df)
print('学生的成绩为:%.2f' % a)
练习:2求100~999所有的水仙花数
# (1) 使用for循环
for i in range(100, 1000):# 取百位数字 123//100=1x = i // 100# 取十位数字 123//10%10=2y = i // 10 % 10# 取个位数字z = i % 10if x ** 3 + y ** 3 + z ** 3 == i:print('%d是水仙花数' % i)
# (2) 使用while循环
n = 100
while n < 1000:x = n // 100y = n // 10 % 10z = n % 10if x ** 3 + y ** 3 + z ** 3 == n:print('%d是水仙花数' % n)n += 1
练习:3.成绩评测系统
while True:score = int(input('请输入分数'))# 定义退出if score == 1:print('结束检测')breakif 90 <= score <= 100:print("学神:成绩爆表!")elif 80 <= score < 90:print("学霸:成绩优秀!")elif 60 <= score < 80:print("学民:成绩及格!")elif 0 <= score < 60:print("学渣:成绩堪忧!")else:print("成绩有误!")print("您的分数为%d" % score)
十 、字典
(1)字典的概念
字典是由元素构成,其中每个元素都是一个键值对
注意:1.字典中的元素是以键值对的形式出现的。
2.键不能重复,而值可以重复。
3.键是不可变数据类型,而值可以是任意数据类型。
(2)字典的创建
dict1 = {} # 创建一个空字典
print(dict1)# 第一种 方式
a1 = [('青春', '奋斗'), ('name', 'everyone')]
dict2 = dict(a1)
print(dict2)# 第二种 方式
d = dict(name='time', key='like')
print(d)# 第三种 方式
dict3 = {'name': 'me', ('my', '青春'): 'miss'}
print(dict3)
(3)计算元素的个数(通过len()函数来获取)
dict3 = {'name': 'me', ('my', '青春'): 'miss'}
print(len(dict3))
(4) 访问元素值
列表与元组是通过下标索引访问元素值,字典则是通过元素的键来访问值
# 第 1 种:直接通过键来访问值
dict3 = {'name': 'me', ('my', '青春'): 'miss'}
print(dict3['name'])
# print(dict3[6]) #访问不存在的键会报错# 第 2 种:使用get()函数访问
dict3 = {'name': 'me', ('my', '青春'): 'miss'}
print(dict3.get('my'))
print(dict3.get('6')) # 访问不存在的键会返回 NONE
(5)修改元素值(通过键修改值)
dict4 = {'name': 'me', ('my', '青春'): 'miss'}
dict4['name'] = 'she'
print(dict4)
(6)添加元素
# 第一种 :通过修改值时,如果键不存在,则会在字典中添加该键值对,默认添加到末尾
dict4 = {'name': 'me', ('my', '青春'): 'miss'}
dict4[('if',)] = '有那么一首歌'
print(dict4)# 第二种:通过update()函数修改某键对应的值或添加元素 ,默认添加到末尾
dict5 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
h = {33: '四季'}
dict5.update(h)
print(dict5)
(6)删除元素
a.删除字典中的元素可以通过 “del字典名[键]”实现,会释放内存空间
k = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
del k['name']
print(k)
b.通过clear()函数删除(清空)字典中所有元素,不会释放内存空间
k1 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
k1.clear()
print(k1)
c.popitem()函数可以随机返回并删除最后一个元素,返回后以元组的形式输出
k2 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
i = k2.popitem()
print(i, k2)
d.pop()函数可以根据指定的键删除元素
k3 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
o = k3.pop(('my', '青春'))
print(o, k3)
(7)复制字典,通过copy()函数来实现
k4 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
p = k4.copy()
print(p)
(8) 成员运算 (in , not in)
k4 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
print('name' in k4)
print(('if',) not in k4)
(9)设置默认键值对,使用setdefault(键,值)函数 如果键值对不在字典中,则会自动添加到末尾
k5 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
u = k5.setdefault('wayback', 'home')
print(u, k5)
(10) 获取字典中所有键 通过keys()函数可以获取字典中所有键
# 1.
k6 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌', 'wayback': 'home'}
print(k6.keys())
# 2.
for key in k6.keys():print(key, end=' ')
# 3.
for key in k6:print(key, end=' ')
(11)获取字典中所有的值 通过values()函数可以获取字典中所有值
k6 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌', 'wayback': 'home'}
# 1.
print(k6.values())
# 2. 通过for循环
for value in k6.values():print(k6)
(12)获取字典中所有的键值对 通过items()函数可以获取字典中所有的键值对
k6 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌', 'wayback': 'home'}
# 1.
print(k6.items())
# 2. 通过for循环
for item in k6.items():print(k6)
(13)遍历字典中的所有键值对
k6 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌', 'wayback': 'home'}
for key, value in k6.items():print('key = %s,value = %s' % (key, value))
(14) 练习题
lis = [{'姓名': '张三', '年龄': 15, '分数': 77},{'姓名': '李四', '年龄': 16, '分数': 89},{'姓名': '老王', '年龄': 17, '分数': 91},{'姓名': '老林', '年龄': 18, '分数': 98},{'姓名': '小张', '年龄': 19, '分数': 99},{'姓名': '小马', '年龄': 20, '分数': 100}]
n = len(lis)
for i in range(n - 1):for j in range(n - i - 1):if lis[j]['分数'] < lis[j + 1]['分数']:lis[j], lis[j + 1] = lis[j + 1], lis[j]
'''使用了两层循环,外层循环控制排序次数,内层循环用来在相邻的元素中比较'分数'键的大小。
如果发现逆序,则将相邻的元素交换位置。通过多次交换,将最大的元素逐渐冒泡到最右侧,
最终实现了按照'分数'键进行降序排序的目的。'''
for k in lis: # 使用遍历对列表中的内容逐行打印print(k)
#
n = len(lis)
for i in range(n - 1):for j in range(n - i - 1):if lis[j]['年龄'] < lis[j + 1]['年龄']:lis[j], lis[j + 1] = lis[j + 1], lis[j]
for l in lis: # 使用遍历对列表中的内容逐行打印print(l)
十一、集合
- 概念:集合是由一组无序排列且不重复的元素组成的。
- .集合使用大括号表示,元素类型可以是数字类型,字符串,元组但不能是列表和字典。
- 使用大括号创建的集合属于可变集合,既可以添加或删除元素,此外,还存在一种 不可变集合,即不允许添加或删除元素。
set1 = {2, [0, '2']} # 错误,集合中有列表
set2 = {2, {'A', 8}} # 错误,集合中有字典
set3 = {2, ('name', 6)} # 正确,元素包含元组
(1)添加元素
①.add()函数
set4, set5 = {'青', '春'},{'是', '那么', '美好'}
set4.add(',')
print(set4)
②.update()函数
set4.update(set5)
print(set4)
(3) 删除元素
集合中删除元素可以使用remove(),discard()函数,clear()函数
set.remove(要删除的元素) #删除不存在的元素会报错
set.discard(要删除的元素) # 删除不存在的元素不会报错
set.clear() 清空集合,不释放内存空间
set6 = {1, 2, 3, 4, 5}
set6.remove(3)
print(set6)
set6.discard(4)
print(set6)
set6.remove(6)
print(set6)
set6.discard(9)
print(set6)
set6.clear()
print(set6)
(4) 集合间的运算
运算 | 说明 |
---|---|
x in set1 | 检测x是否在集合set1中 |
set1 == set2 | 判断集合是否相等 |
set1 <= set2 | 判断set1是否是set2的子集 |
set < set2 | 判断set1是否是set2的真子集 |
set >= set2 | 判断set1是否是set2的超集 |
# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是:{set3}")
print(f"取差集后,原有set1的内容:{set1}")
print(f"取差集后,原有set2的内容:{set2}")# 消除2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后,集合1结果:{set1}")
print(f"消除差集后,集合2结果:{set2}")# 2个集合合并为1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果:{set3}")
print(f"合并后集合1:{set1}")
print(f"合并后集合2:{set2}")
(5) 集合常用功能总结
编号 | 操作 | 说明 |
---|---|---|
1 | 集合.add(元素) | 集合内添加一个元素 |
2 | 集合.remove(元素) | 移除集合内指定的元素 |
3 | 集合.pop() | 从集合中随机取出一个元素 |
4 | 集合.clear() | 将集合清空 |
5 | 集合1.difference(集合2) | 得到一个新集合,内含2个集合的差集 原有的2个集合内容不变 |
6 | 集合1.difference_update(集合2) | 在集合1中,删除集合2中存在的元素 集合1被修改,集合2不变 |
7 | 集合1.union(集合2) | 得到1个新集合,内含2个集合的全部元素 原有的2个集合内容不变 |
8 | len(集合) | 得到一个整数,记录了集合的元素数量 |
(6) 集合的遍历
- 集合不支持下标索引,不能用while循环
- 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:print(f"集合的元素有:{element}")
(7) 统计集合元素数量len()
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量有:{num}个")
(8) 集合的存储原理
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4JNUftTZ-1687660802300)(null)]
(9) 元素必须可哈希
因存储原理,集合的元素必须是可哈希的值,即:内部通过通过哈希函数把值转换成一个数字。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RtH997LG-1687660802193)(null)]
目前可哈希的数据类型:int、bool、str、tuple,而list、set是不可哈希的。
总结:集合的元素只能是 int、bool、str、tuple 。
-
转换成功
v1 = [11,22,33,11,3,99,22] v2 = set(v1) print(v2) # {11,22,33,3,99}
-
转换失败
v1 = [11,22,["alex","eric"],33] v2 = set(v1) # 报错 print(v2)
(10) 查找速度特别快
因存储原理特殊,集合的查找效率非常高(数据量大了才明显)。
-
低
user_list = ["武沛齐","alex","李璐"] if "alex" in user_list:print("在") else:print("不在")user_tuple = ("武沛齐","alex","李璐") if "alex" in user_tuple:print("在") else:print("不在")
-
效率高
user_set = {"武沛齐","alex","李璐"} if "alex" in user_set:print("在") else:print("不在")
(11) 对比和嵌套
类型 | 是否可变 | 是否有序 | 元素要求 | 是否可哈希 | 转换 | 定义空 |
---|---|---|---|---|---|---|
list | 是 | 是 | 无 | 否 | list(其他) | v=[]或v=list() |
tuple | 否 | 是 | 无 | 是 | tuple(其他) | v=()或v=tuple() |
set | 是 | 否 | 可哈希 | 否 | set(其他) | v=set() |
data_list = ["alex",11,(11, 22, 33, {"alex", "eric"}, 22),[11, 22, 33, 22],{11, 22, (True, ["中国", "北京"], "沙河"), 33}
]
注意:由于True和False本质上存储的是 1 和 0 ,而集合又不允许重复,所以在整数 0、1和False、True出现在集合中会有如下现象:
v1 = {True, 1}
print(v1) # {True}v2 = {1, True}
print(v2) # {1}v3 = {0, False}
print(v3) # {0}v4 = {False, 0}
print(v4) # {False}
十二、函数
(1) 变量作用域
变量作⽤域指的是变量⽣效的范围,主要分为两类:局部变量和全局变量。
-
局部变量
所谓局部变量是定义在函数体内部的变量,即只在函数体内部⽣效
def testA():a = 100 print(a) testA() # 100 print(a) # 报错:name 'a' is not defined
变量a是定义在 testA 函数内部的变量,在函数外部访问则⽴即报错。
-
全局变量
所谓全局变量,指的是在函数体内、外都能⽣效的变量。
思考:如果有⼀个数据,在函数A和函数B中都要使⽤,该怎么办?
答:将这个数据存储在⼀个全局变量⾥⾯
#定义全局变量a a = 100
def testA():print(a) # 访问全局变量a,并打印变量a存储的数据
def testB():print(a) # 访问全局变量a,并打印变量a存储的数据testA() # 100
testB() # 100
思考: testB 函数需求修改变量a的值为200,如何修改程序
a= 100 def testA():print(a)def testB():a = 200 print(a) testA() # 100
testB() # 200
print(f'全局变量a = {a}') # 全局变量a = 100
思考:在 testB 函数内部的 a = 200 中的变量a是在修改全局变量 a 吗?
答:不是。观察上述代码发现,15⾏得到a的数据是100,仍然是定义全局变量a时候的值,⽽没有返回testB 函数内部的200。综上: testB 函数内部的 a = 200 是定义了⼀个局部变量。
思考:如何在函数体内部修改全局变量?
a = 100def testA():print(a)
def testB():# global 关键字声明a是全局变量量global aa = 200print(a)
testA() # 100
testB() # 200
print(f'全局变量量a = {a}') # 全局变量量a = 200
(2)多函数程序执行流程
一般在实际开发过程中,一个程序往往由多个函数组成,并且多个函数共享某些数据,如下所示:
- 共用全局变量量
# 1. 定义全局变量量
glo_num = 0def test1():global glo_num# 修改全局变量量glo_num = 100def test2():# 调⽤用test1函数中修改后的全局变量量print(glo_num)# 2. 调⽤用test1函数,执⾏行行函数内部代码:声明和修改全局变量量
test1()
# 3. 调⽤用test2函数,执⾏行行函数内部代码:打印
test2() # 100
- 返回值作为参数传递
def test1():return 50def test2(num):print(num)# 1. 保存函数test1的返回值
result = test1()# 2.将函数返回值所在变量量作为参数传递到test2函数
test2(result) # 50
(3)函数的返回值
思考:如果⼀个函数如些两个return (如下所示),程序如何执行?
def return_num():return 1return 2result = return_num()
print(result) # 1
答:只执行了了第一个return,原因是因为return可以退出当前函数,导致return下⽅方的代码不不执行。
思考:如果一个函数要有多个返回值,该如何书写代码?
def return_num():return 1, 2result = return_num()
print(result) # (1, 2)
注意:
- return a, b写法,返回多个数据的时候,默认是元组类型。
- return后⾯面可以连接列列表、元组或字典,以返回多个值。
(4)函数的参数
1 .位置参数
位置参数:调⽤用函数时根据函数定义的参数位置来传递参数。
def user_info(name, age, gender):print(f'您的名字是{name}, 年年龄是{age}, 性别是{gender}')user_info('TOM', 20, '男')
注意:传递和定义参数的顺序及个数必须⼀致。
2 .关键字参数
函数调⽤用,通过“键=值”形式加以指定。可以让函数更更加清晰、容易易使⽤用,同时也清除了了参数的顺序需求。
def user_info(name, age, gender):print(f'您的名字是{name}, 年年龄是{age}, 性别是{gender}')user_info('Rose', age=20, gender='⼥女女')
user_info('⼩小明', gender='男', age=16)
注意:函数调⽤用时,如果有位置参数时,位置参数必须在关键字参数的前⾯面,但关键字参数之间不不存在先后顺序。
3 .缺省参数
缺省参数也叫默认参数,⽤用于定义函数,为参数提供默认值,调⽤用函数时可不不传该默认参数的值(注意:所有位置参数必须出现在默认参数前,包括函数定义和调⽤用)。
def user_info(name, age, gender='男'):print(f'您的名字是{name}, 年年龄是{age}, 性别是{gender}')user_info('TOM', 20)
user_info('Rose', 18, '⼥女女')
注意:函数调⽤用时,如果为缺省参数传值则修改默认参数值;否则使⽤用这个默认值。
4.不定长参数
不定长参数也叫可变参数。⽤用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。
-
*P 传递
def user_info(*args):print(args)# ('TOM',)
user_info('TOM')
# ('TOM', 18)
user_info('TOM', 18)
注意:传进的所有参数都会被args变量量收集,它会根据传进参数的位置合并为一个元组(tuple),args是元组类型
-
**P 传递
def user_info(**kwargs):print(kwargs)# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM', age=18, id=110)
注意:以字典的形式传递
(5)总结
- 变量量作⽤用域
全局:函数体内外都能⽣生效
局部:当前函数体内部⽣生效
-
函数多返回值写法
-
函数的参数
位置参数 形参和实参的个数和书写顺序必须⼀一致
关键字参数 写法: key=value,特点:形参和实参的书写顺序可以不不⼀一致;关键字参数必 须书写在位置参数的后⾯面
缺省参数 1 return 表达式1, 表达式2…
缺省参数就是默认参数
写法: key=vlaue
不定长位置参数
收集所有位置参数,返回⼀个元组
不定长关键字参数
收集所有关键字参数,返回⼀一个字典
引用:Python中,数据的传递都是通过引用
十三、.可变和不可变类型
所谓可变类型与不可变类型是指:数据能够直接进行修改,如果能直接修改那么就是可变,否则是不可变。
- 可变类型
- 列表
- 字典
- 集合
2.不可变类型
- 整型
- 浮点型
- 字符串
- 元组
更多推荐
走进python三千章,自信人生二百年——python学习笔记
发布评论