B站小甲鱼Python基础学习课堂笔记

已于 2022-12-04 21:59:35 修改
阅读量1.2k 收藏 12
点赞数 2
分类专栏： Python基础学习 文章标签： python pycharm 职场和发展
于 2022-10-30 21:44:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41078094/article/details/126344875
版权

1. 变量

（1）如何创建变量
创建变量直接可以用变量名=值，不用声明数据类型

（2）如何访问变量
使用变量名访问变量

（3）变量的操作
变量的值取决于最后一次赋值操作

  1. 两个变量的值可以互相传递
  2. 两个变量的值可以互等
  3. 两个变量的值的互换（传统方法是设置一个临时变量，更方便的方法是）
#交换两个变量的值
x=3
y=5
x,y=y,x
print(x)  #此时x和y的值直接调换

2. 数据类型

2.1 字符串

2.2.1 创建字符串

（1）Python字符串的编写方式

  1. single quotes，使用单引号将文本括起来
print('like this')
  1. double quotes，使用双引号将文本括起来，要保证字符串两边的引号是成双成对的
print("I'm so cute!")
  1. triple quotes，如果有双层引号，最外面的一定是双引号
print("she said,'I am cute!'")
  1. 如果文本中自带单引号和双引号，用转义符号，表示此字符没有其他语法含义只是字符
print('\"she said,\'I am cute!\'\"')
print("\"she said,\'I am cute!\'\"")
# 使用转义字符，在文本的引号符号前加斜杠

2.2.2 字符串常用方法

2.2.2.1 字母大小写转换
x="I like Python"
# 首字母转为大写
a=x.capitalize() #注意返回的不是原字符串，而是会创建一个新的字符串数据
# 将字符串全部转为小写（可以处理多种语言）
b=x.casefold()
# 将每个单词的首字母大写
c=x.title()
# 将字符串的大小写反转
d=x.swapcase()
# 将原字符串的每个字母都大写
e=x.upper()
# 将原字符串的每个字母都小写（只能处理英语）
f=x.lower()
print(x,' ',a,' ',b,' ',c,' ',d,' ',e,' ',f,' ')
2.2.2.2 对齐
x="100"
print(x.center(10))
print(x.ljust(10))
print(x.rjust(10))
# 左侧用0填充
print(x.zfill(10))
print("-100".zfill(10))

# 以上前三种对齐方法还可以自定义填充的字符，默认的话就是空格
print(x.center(10,"*"))
print(x.ljust(10,"*"))
print(x.rjust(10,"*"))
2.2.2.3 计数索引
x="i like python"
print(x.count("i",0,2))
print(x.find("i",0,3))
print(x.rfind("i",0,6)) #没有不会报错
print(x.index("i",0,8)) #没有会报错
2.2.2.4 替换
y="i like python"
# 替换，指定一个tab为多少个空格
print(y.expandtabs(1))
# 替换指定字符,后面的数字是指在多个相关指定字符串的情况下，指定替换几个
print(y.replace("i","a",2))
# 表格替换，先创建一个表格，再将其作为参数，替换原字符串对应的字符为表格中的，表格还可以设置忽略哪些字符串
table=str.maketrans("lipy","1234","like")
y_=y.translate(table)
print(y_)

在这里插入图片描述

2.2.2.5 判断
  • 判断字符串位置
    判断参数指定的子字符串是否出现在原字符串的起始位置，返回布尔类型
y="i like python"

# 判断指定的子字符串是否出现在字符串的起始位置，返回布尔类型
# 可选参数是指定查找的范围，开始和结束的下标（但包头不包尾）
print(y.startswith("i",3,5))
# 判断指定的子字符串是否出现在字符串的结束位置，返回布尔类型
print(y.endswith("i",0,3))

# 支持元组的形式传入待匹配的字符串,只要有一个匹配成功就返回true
print(y.startswith(("i","o","p")))
  • 字母
y="i like python"
# 判断所有字符串是不是都是以大写字母开头
print(y.istitle())
# 判断所有字母是不是都是大写字母
print(y.isupper())
# 连续调用多个方法，是从左向有调用的
print(y.upper().isupper())
# 判断所有字母是不是都是小写字母
print(y.islower())
# 判断字符串是不是都是字母元素
print(y.isalpha())
# 判断是不是空白字符串(转义字符也是空白字符）
print(" \n".isspace())
# 判断是字符串是否可打印（数字，字母，空格，标点符号等）
print(" \n".isprintable())
  • 数字
# 判断字符串是不是都是数字
print(y.isdigit())
# 判断字符串是不是十进制
print(y.isdecimal())
# 判断是不是数字（接收范围最大，阿拉伯数字，中文数字，
print(y.isnumeric())
# 以上三者的集大成者
print(y.isalnum())
  • 判断标识符
y="if"
# 判断字符串是否合法标识符
print(y.isidentifier())

# 判断保留标识符（类似if for这种）
# 引入模块
import keyword
# 调用模块中的iskeyword函数
print(keyword.iskeyword(y))
2.2.2.6 截取字符串
  • 去除左侧右侧空格
# 去除空格
print("     去除左侧空空空白")
print("     去除左侧空空空白".lstrip())
print("去除右侧空空空白     ".rstrip())
print("     去除左侧和右侧的空空空白    ".strip())
  • 按单个字符匹配去除左侧右侧字符
# lstrip，按单个字符逐个匹配去除，直到左侧第一个字符不是参数包含的字符为止
print("kkkk去除左侧空空空白".lstrip("k"))
# rstrip，按单个字符逐个匹配去除，直到右侧第一个字符不是参数包含的字符为止
print("去除右侧空空空白kkkk".rstrip("k"))
# strip，按单个字符逐个匹配去除，直到字符串左侧和右侧的第一个字符都不是参数包含的字符为止
print("kkkk去除左侧和右侧的空空空白kkkk".strip("k"))
  • 按整个字符串精准匹配去除左侧右侧字符
# 精准去除指定子字符串
print("空白空白去除左侧的".removeprefix("空白"))
print("去除右侧的空白空白".removesuffix("空白"))
2.2.2.7 字符串拆分和拼接

将原字符串按照参数指定的分割符进行拆分，并返回三元组（三个元素的元组）
分从左往右和从右往左

# 将原字符串按照参数指定的分割符进行拆分，并返回三元组（三个元素的元组）
y="i like python"
# partition从左至右切割，返回的三元组分别是切割符左侧的内容、切割符、切割符右侧的内容（从碰到的第一个切割符那里开始切割）
print(y.partition(" "))
# partition从右至左切割，返回的三元组分别是切割符左侧的内容、切割符、切割符右侧的内容
print(y.rpartition(" "))

在这里插入图片描述

将原字符串按照指定参数进行切割，返回一个列表,列表是切割后的元素
分从左往右和从右往左

y="i.like.python"
# 将原字符串按照指定参数进行切割，返回一个列表,列表是切割后的元素
print(y.split("."))
# 不加参数的话，默认按照空格或者\n来切分，原字符串没有空格就直接返回整个字符作为列表的唯一元素
print(y.split())
# 第二个参数是指定切割的次数
print(y.split(".",1))
print(y.rsplit(".",1))

字符串拼接，将列表的元素用同一个字符串拼接起来

# 字符串拼接，将列表的元素用同一个字符串拼接起来（还可以用加号进行拼接，但是对于大型数据，效率是很低的
print("..".join(['i', 'like', 'python']))
2.2.2.8 格式化字符串
  • 格式化字符串
# （有点像前端的知识）
year=1998
# {}是占位符号，真正需要显示的内容放在format里面
print("我出生于{}年".format(year))
# {}里面可以定义选择format里面的哪一个参数，format的参数相当于元组（不可变序列）
print("我出生于{0}年，你出生在{0}年".format(1998,2001))
# 还可以使用关键字参数来自定义
print("我喜欢看{book}，我喜欢吃{food}".format(book="科普书籍",food="鸡腿"))
# 纯输出{}
print("{}".format("{}"))  # 放入内容
print("{{}}".format())    #用花括号注释花括号
  • 字符串的对齐与填充
#  对齐与填充
# 输出10宽度字符串，其中format的内容放中心，其他用空格填充
print("{:^10}".format(250))
# 输出10宽度的字符串，其中format的内容放最右，其他用空格填充
print("{:>10}".format(250))
# 输出10宽度字符串，其中format的内容放最左，其他用空格填充
print("{:<10}".format(250))
# 多个元素的情况下，可以指定哪个放最前，哪个放最后
print("{0:<10}{1:>10}".format(150,250))
print("{left:<10}{right:>10}".format(left=150,right=250))
# 在指定宽度前加0，使用0填充感知数值正负号（只针对数值有作用）
print("{:010}".format(-250))
# 在指定宽度前加别的什么符号进行填充
print("{:%=10}".format(-250))
2.2.2.9 格式化数值
  • 正负数和千位切分
print("{:+},{:-}".format(-250,250))  #负号只对负数起作用
# _和,可作为千位分割符，位数不够是不进行切分的
print("{:,}".format(1234))
print("{:_}".format(1234))
# 直接截取字符的前几位
print("{:.2}".format("1234 1234"))
  • 精度表现形式
    在这里插入图片描述
# 精度选项（精度选项不用于整数）
print("{:.2f}".format(111.234))  #保留小数点后2位
print("{:.2g}".format(111.234))  #保留小数点前后2位
  • 整数的表示形式
    在这里插入图片描述
# 十进制转其他进制
print("{:#b}".format(10)) #二进制
print("{:c}".format(50))  #Unicode字符
print("{:#d}".format(10)) #十进制
print("{:#o}".format(10)) #八进制
print("{:#x}".format(10)) #十六进制

# 二进制转其他进制
print("{:#d}".format(0b1010)) #十进制
print("{:#b}".format(0b1010)) #二进制
print("{:#o}".format(0b1010)) #八进制
print("{:#x}".format(0b1010)) #十六进制
  • 小数的表示形式
    在这里插入图片描述
# 科学计数法
print("{:e}".format(0.11111))
print("{:E}".format(0.11111))
# 定点表示法
print("{:f}".format(0.11111))
# 通用格式
print("{:g}".format(1111111111))
print("{:g}".format(111.1111111))
# 百分号格式
print("{:%}".format(0.1111111111))
# 自定义百分号格式
print("{:.2%}".format(0.1111111111))
y=3
print("{:.{x}%}".format(0.1111111111,x=y))
print("{:{fill}{alien}{width}.{x}{ty}}".format(0.1111111111,fill="+",alien="^",width=10,x=3,ty="g"))
  • f字符串
    注意只适用于3.6及以上版本
year=1998
# f字符串直接将需要格式化的内容放在花括号就行
print(f"我出生于{year}年")
# 格式化数值的，就放在冒号左面
print(f"{0.11111:.2%}")

2.2 数值类型

2.2.1 整数

Python的整数长度不受限制，具有无限大的精度

2.2.2 浮点数

python 浮点数计算是具有误差的

真正的原因在于十进制和数和二进制数的转换：
计算机不认识十进制数，只认识二进制数，当我们以十进制数进行运算的时候，计算机需要将各个十进制数转换成二进制数，然后进行二进制间的计算。
以类似 0.1 这样的浮点数为例，如果手动将其转换成二进制，其结果为：0.1 (十进制)=0.00011001100110011… (二进制)
可以看到，结果是无限循环的，也就是说，0.1 转换成二进制数后，无法精确到等于十进制数的 0.1。同时由于计算机存储的位数是有限制的，所以如果要存储的二进制位数超过了计算机存储位数的最大值，其后续位数会被舍弃（舍弃的原则是“0 舍 1 入”），此时误差就出现了。
原文路径1

目前Python和C语言的浮点数存储标准都是IEEE754
使用这个标准进行计算形成误差如下图，其误差形成的具体过程见这个链接
在这里插入图片描述

那么如何利用Python精确的计算浮点数？
使用模块：decimal 支持快速正确舍入的十进制浮点运算

# 引入decimal模块
import decimal
#使用decimal实例化对象(字符串)，进行十进制浮点计算
b=decimal.Decimal("0.1") 
c=decimal.Decimal("0.2")
a=b+c
print(a)

2.2.3 复数

复数包含一个实部和一个虚部

# 复数
num=1+2j
print(num.real) #输出复数的实部
print(num.imag) #输出复数的虚部

2.3 布尔类型

性质1：
如果传入的是字符串，除了空字符串其他的都是true
如果传入的是数值除了0,其他的都是true
结果为false的情况：

  1. 定义为False的对象：None和False
  2. 值为0的数字类型：0，0.0，0j，Decimal(0)，Fraction(0,1)（分子为0分母为1的有理数）
  3. 空的序列和集合：‘’，()，[]，{}，set()，range(0)

性质2：
布尔类型就是特殊的整数类型

True==1
False==0

2.4 列表

2.4.1 列表是什么

列表是python中数据类型其中的一种,关键字是list。列表(list)是一种可变序列类型，我们可以追加、插入、删除和 替换列表中的元素。列表也是可迭代的对象

2.4.2 创建列表和获取列表元素的值

（1）列表可以容纳不同类型的数据
（2）下标索引的方式可以得到列表的某一个元素
（3）for循环可以遍历列表的所有元素

a=[1,2,"hao",4] #创建一个列表，列表中的元素可以是整数、浮点数类型也可以是字符串类型
print(a[0]) # 下标索引单独访问列表的某一个元素
print(a[-1]) # 索引值可以倒序，最后一个元素的索引值可以是-1，前面的倒推
for i in a:
    print(i) #遍历

2.4.3 列表切片

# 列表切片
a=[1,2,"hao",4,"hhh",5,6,7]
print(a[0:2])
print(a[:2])
print(a[3:7])
print(a[3:])
print(a[:])
print(a[1:6:2])
print(a[:6:2])
print(a[1::2])
print(a[::2])

在这里插入图片描述

2.4.4 列表基本操作方式

（1） 增

  • append函数，在元素末尾追加单个元素
  • extend函数，增加多个元素，参数是一个可迭代对象，新的内容是追加到原列表最后一个元素后面
s=[1,2,3,4,5]
s.append(1)
s.extend([1,2])
print(s)
  • insert函数，在指定位置追加元素
s=[1,2,3,4,5]
s.insert(0,0)
print(s)

（2） 删

  • remove函数，如果列表中有多个匹配的元素，那么只会删除第一个，如果指定的元素不存在那么会报错
  • pop函数，根据下标删除函数
  • clear函数，清除列表
s=[1,2,3,4,5]
s.remove(2)  #删除指定元素
s.pop(2)     #根据下标删除函数
s.clear()    #清空列表
print(s)

（3） 改

  • 用切片的方式修改列表内元素（因为列表是可变序列类型，所以它的元素是可以修改的）
s=[1,2,3,4,5]
s[1]="23"        #改下标为1的元素
s[0:2]=[7,8]     #改下标为0,1的元素
print(s)
  • 列表的排序方法
s=[1,2,3,4,5]
s.sort()  #自带的升序方法
s.reverse()   #反转方法
s.sort(reverse=True)   #自定义sort的排序方式
print(s)

a=["Dogs","App","Can","Banana"]
# 原地对列表进行从小到大的排序（如果是字符类型就是按编码大小排序），改变了原列表
a.sort()
print(a)
# sort函数的key参数可以指定干预排序算法的函数，在这里是指定按照元素长度排序
a.sort(key=len,reverse=True)

（4） 查

s=[3,2,3,4,5]
x=s.count(2)       #计数，有多少个该元素
y=s.index(3,1,4)   #获取某元素的下标值，可以设置查找的开始和结束的区间（查找元素3，查找区间为1-4）

（5）切片方法实现增改删

s=[1,2,3,4,5]
s[1:1]=[0]       #任意位置插入（插入到下标为1 的位置）
s[len(s):]=[0]   #在序列最后面插入
s[1:2]=[]        #删除（下标为1的元素）
s[0:2]=[]        #删除（下标为0-1的元素）
s[1]="23"        #改下标为1的元素
s[0:2]=[7,8]     #改下标为0,1的元素
print(s)

链接: 列表的各种方法大合集

2.4.5 列表的嵌套

这部分实际上运用到了线性代数的矩阵相关知识

1、列表的加法和乘法（拼接）
（1）列表加法：将两个或多个列表元素总和到一起
（2）列表乘法：将一个列表的元素重复N次

2、列表的嵌套也就是在列表中再添加列表，形成矩阵（matrix）
（1）嵌套列表长啥样
（2）嵌套列表如何访问

# 创建嵌套列表
matrix=[[1,2,3,4],
        [5,6,7,8],
        [9,10,11,12]]
# 遍历列表
for i in matrix:
    for j in i:
        print(j,end=' ')
    print("")
# 根据下标访问列表元素
print(matrix[1][1])

2.4.6 列表的浅拷贝和深拷贝

变量不是盒子，变量与数值之间的关系是引用

（1）直接赋值是两个变量引用同一个数据，指向同一个存放数据的空间
Python对于不同的对象的存储机制不一样，比如字符串是不可变，对应存储只需要开辟一个空间存放即可，不同的变量名指向同一个字符串，也可以直接找到对应的数据，但是对于列表来说，列表是可变的对象，即使两个变量名对应的列表内容是一样的，还是会开辟两个存储空间存放列表

# 用for循环创建嵌套列表
A=[0]*3
for i in range(0,3):
    A[i]=[0]*3
print(A)
print(A[1] is A[0])

# 错误用法
B=[[0]*3]*3
print(B)
print(B[1] is B[0])在这里插入代码片

在这里插入图片描述
错误的通过乘法复制出来的嵌套列表，会出现一下情况，嵌套列表外层对象的子对象均指向同一个列表对象
在这里插入图片描述

（2）浅拷贝，复制出一个新的独立列表
但，浅拷贝只能拷贝嵌套列表的外层对象，而子对象则是直接引用，因此如果是拷贝嵌套列表，则会出现以下情况：

x=[[1,2,3],
    [4,5,6],
    [7,8,9]]
y=x.copy()    #copy列表（列表自带的浅拷贝方法）
y=x[:]       #copy列表（切片浅拷贝）
print(x,y)
x[1][1]=0
print(x,y)

在这里插入图片描述
在这里插入图片描述

（3）深拷贝，复制出一个新的独立列表，在拷贝外层的对象的同时，也拷贝了子对象

import copy
A=[[1,2,3],
    [4,5,6],
    [7,8,9]]
# 深拷贝
D=copy.deepcopy(A)
print(D," ",D is A,D[1] is A[1])

在这里插入图片描述

import copy
A=[[1,2,3],
    [4,5,6],
    [7,8,9]]
# 赋值
B=A
print(B," ",B is A,B[1] is A[1])
# 浅拷贝
C=A.copy()
print(C," ",C is A,C[1] is A[1])
# 深拷贝
D=copy.deepcopy(A)
print(D," ",D is A,D[1] is A[1])

在这里插入图片描述

2.4.7 列表推导式

列表推导式的效率较循环语句高将近一倍，因为列表推导式是使用C语言的速度运行，比Python脚本的虚拟机PVM以步进的速度运行循环语句要快得多。

（1）利用循环逐个修改列表的元素

x=[1,2,3]
for i in range(len(x)):
    x[i]=x[i]*2
print(x)

（2）利用列表推导式直接修改原列表的数据
列表推导式的结果一定是列表，其中包含表达式（相当于循环体）和for循环的头

x=[1,2,3]
x=[i*2 for i in x]
print(x)

两者区别：前者是通过修改原列表的值，后者是直接创建一个新列表并将其赋值给原列表的变量

（3）矩阵的列表推导式

A=[[1,2,3],
    [4,5,6],
    [7,8,9]]
#循环取A的每一行的下标为2的元素，创建一个新一维列表并赋值给a
a=[i[2] for i in A]
print(a)
#取对角线的值（主对角线）
b=[A[i][i] for i in range(len(A))]
print(b)
#取对角线的值（副对角线）
c=[A[i][len(A)-i-1] for i in range(len(A))]
print(c)

（4）列表推导式的拓展

  • 可以加if判断，执行顺序是先for语句再if最后是表达式
  • 可以加嵌套循环，外层循环在前，内存循环在后
  • 还可以两者结合
x=["Faa","Fdd","Cdd","Gdd"]
# 加if
a=[i for i in x if i[0]=="F"or"f"]
print(a)
# 加循环嵌套
b=[j for i in x for j in i ]
print(b)
# 两者结合
c=[j for i in x if i[0]=="F" for j in i]
print(c)

在这里插入图片描述

2.5 元组

2.5.1 元组和列表的关系

（1）元组的基本性质

  • 列表是方括号，元组是圆括号（也可以不要括号）
  • 查看元组的数据，跟列表一样
  • 元组是不可变序列类型，一般情况下它的元素不可变（但如果元组的元素是可变的列表类型的话也是可以改变的）
  • 元组支持用切片
  • 列表的内置方法，元组基本都可以使用
  • 元组支持用加法（拼接）和乘法
  • 元组支持嵌套
  • 元组需要包含至少一个逗号
x=(1,2,3)
y=(4,5,6)
# 切片
print(x[2])
print(x[1:])
# 自带方法
print(x.index(2))
print(x.count(2))
# 加法和乘法
print(x+y)
print(x*2)
# 嵌套
z=x,y
print(z)
for i in z:
    for j in i:
        print(j,end=" ")

2.5.2 元组的打包和解包（适用于其他所有序列类型）

  1. 打包是元组的创建
  2. 解包是指将元组的元素一一赋值给其他变量
# 解包
a,b,c=x
print(a,b,c)
print(x)

2.6 序列

2.6.1 字符串、列表、元组的异同点

（1）共同点

  1. 索引：都可以通过下标索引查找元素，第一个元素的索引值都是0
  2. 都可以通过切片的方式获取子集
  3. 有很多共同的运算符
  4. 它们都是序列

（2）不同点

  1. 列表是可变序列（其中的元素可以改变）
  2. 元组和字符串是不可变序列（其中的元素不可改变，出发其中的元素本身是可变序列）

2.6.2 Python对象三要素

在Python中每一个对象都有三个属性：身份、类型、值

  1. 身份：每个对象都有一个唯一的身份标识自己，对象的身份可以用内建函数id()来得到。这个值可以被认为是该对象的内存地址。
  2. 类型：描述一种对象的类型所需要的信息不能也不应该和数据保存在一起，所以我们将类型定义成对象，这就是说类型对象，所有类型对象的类型都是type。可以用内建函数type()查看对象的类型。
  3. 值：对象表示的数据项，如果对象支持更新操作，那么它的值就可以改变，否则它的值就是只读的，对象的值是否可以改变被称为对象的可改变性。
    判断两个对象是否相同，可以用is 和 is not运算符判断

不可变序列对象：id指向内存地址，当不可变序列内容改变相当于重新生成了一个新变量，其id发生改变（除非是不可变序列中的可变序列发生变化，这种情况id是不变的）

# 不可变序列，内容改变id改变
# 字符串
e="123"
print(id(e))
e*=2
print(id(e))

# 元组
f=(1,2,3)
print(id(f))
f*=2
print(id(f))
# 元组的可变序列元素发生变化，id不变
g=([1,2,3],2,3)
print(id(g))
g[0][2]=2
print(g)
print(id(g))

python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量。因此两个保存相同字符串的不同变量的唯一标识是相同的
驻留机制

# 不可变序列
# 字符串，驻留机制，两个保存相同字符串的不同变量的唯一标识相同
e="123"
f="123"
print(id(e))
print(id(f))
print(e is f)

# 元组
a=(1,2,3)
b=(1,2,3)
print(id(a))
print(id(b))
print(a is b)

可变序列对象：id指向内存地址，可变序列对象id在被定义内容改变之后也是不变的（注意：但是重新定义的同名的对象是不同的对象，此时会开辟两个不同的内存）

# 相同的对象
s=[1,2,3]
print(id(s))
s*=2
print(id(s))
#不同的对象
s=[1,2,3]
print(id(s))
s=2
print(id(s))

2.6.3 序列常用的运算符和函数

2.6.3.1 可用于序列的运算符
  1. 加 和 乘：加是增加元素，乘是复制N次元素
  2. is 和 is not：同一性运算符辨认对象的唯一标识，判断对象是不是同一个
  3. in 和 in not：判断是否包含，符号左右两边分别是需要在列表中查找的值以及列表对象
  4. del：删除一个或多个指定的对象，删除可变序列中的指定元素
# in 和 not in在符号左右两边分别是需要在列表中查找的值（类型必须是对象的元素类型）以及列表对象
# 列表的元素是整数类型，如果符号左边是列表类型，将无法判断为包含关系
a=[1,2,3]
b=[1]
print(b in a)
# 如果符号左边是整数类型，才能判断为包含关系
a=[1,2,3]
b=[1]
print(1 in a)

# 如果符号左边是字符串类型，右边对象的元素也是字符串类型，可以判断
c="123"
d="1"
print(d in c)

e=(1,2,3)
f=(1)
print(1 in e)

# del删除
a=[1,2,3]
b=[1,2,3,4,5,6,7,8]
del a
# 用切片也可以操作，切片删除的原理是先清除再插入空列表
del b[0:1]
# print(a)
print(b)
# 设置删除元素的步进为2，从下标为0的元素开始删除，删除0,2,4,6
del b[::2]
print(b)
2.6.3.2 序列可用的函数
（1）列表、字符串、元组相互转换的函数
  • list()：可迭代对象转换为列表
  • tuple()：可迭代对象转换为元组
  • str()：传入对象转换为字符串
（2）输出最小和最大值
  • max()
  • min()

两种方法，一种是传入可迭代序列对象，一种是直接传入需要比较的一些值

# 对于元素是数值的，比较的是元素的值
A=[1,2,3]
print(max(A))
# 对于元素是字符的，比较的是元素的编码
B="abc"
print(max(B))
print(max(1,2,3))

# 可以设置一个异常提醒的值
C=[]
print(max(C,default="是空的"))
（3）len和sum函数
  • len()，求可迭代对象的长度，但是如果参数太大会报错，因为是直接读取C语言结构体的对象的长度，32位平台最大长度限制是2的31次方减1，64位平台最大长度限制是2的63次方减1（Python内部很多都是通过C语言进行计算）
  • sum()，对可迭代对象中的数值进行求和，sum()可以指定求和计算的起始值
a="123"
print(len(a))

b=[1,2,3]
print(sum(b,start=10)) #指定起始值，从10开始加起
（4）排序函数
  • sorted()：sort函数跟这个长得很像，sort()函数是对列表原地排序且只能处理列表；sorted()排序后返回一个新的对象且能对任何可迭代序列进行操作，但是返回的结果都是列表
a=["Dogs","App","Can","Banana"]
# 原地对列表进行从小到大的排序（如果是字符类型就是按编码大小排序），改变了原列表
a.sort()
print(a)
# sort函数的key参数可以指定干预排序算法的系统封装的回调函数，在这里是指定按照元素长度排序：每个元素都会进行一次len函数操作，并返回元素长度的值，sort函数则会对这些返回的长度值进行排序
a.sort(key=len,reverse=True)
print(a)

a=["Dogs","App","Can","Banana"]
# 输出的是全新的列表，原列表不变， 如果两个元素一样，按照默认位置排序
print(a)
print(sorted(a,key=len,reverse=True))
  • reversed()：返回一个反向的迭代器（相当于一个可迭代对象），也是对任何可迭代对象都能进行操作
a=[3,2,3,6,2,0]
print(reversed(a)) #返回一个可迭代对象
# 将返回的这个可迭代对象转为列表，就得到一个反向的列表
print(list(reversed(a)))
（5）迭代器
  • enumerate()函数：返回一个枚举对象，将可迭代序列中的每个元素及从0开始的序号共同构成一个二元组的列表（列表的元素是二元组），可以自行定义序号的起始值
# 将列表元素抽取出来，然后跟索引构成一个二元组枚举对象
b=["一","二","三","四","五"]
print(list(enumerate(b)))
print(list(enumerate(b,100)))  #可以自定义索引的起始值
  • zip()函数：创建一个聚合多个可迭代对象的迭代器，将参数传入的每个可迭代对象的每个元素依次组合成元组以迭代器的形式返回，即第i个元素包含来自每个参数的第i个元素（长度以最短的为准）
    还可以用itertools模块的zip_loogest函数，对不同长度的可迭代对象进行zip，长度不够的默认为none
# 可迭代对象长度一致
a=[1,2,3,4,5]
b=["一","二","三","四","五"]
print(list(zip(a,b)))
# 可迭代对象长度不一致，以短的为主
c=["a","b","c","d"]
print(list(zip(a,c)))
# 长度不一致可以用itertools模块中的zip_longest函数，保留所有元素
import itertools
print(list(itertools.zip_longest(a,c)))
  • map()函数：根据指定运算函数对可迭代对象每个元素进行计算，并以迭代器的形式返回计算结果。map(运算方式的函数，运算对象1，运算对象2)。如果运算对象长度不一致，跟zip()处理方式一样，以最短的为准
# 指定运算函数
print(list(map(ord,"b")))
print(list(map(pow,[1,2,3],[4,5,6])))
  • filter()函数：根据指定运算函数对可迭代对象每个元素进行计算，并运算结果为真的元素，以迭代器的形式返回（返回的迭代器需要通过转换为序列的函数转换为需要的列表、元组或者字符串）
# 指定运算函数的函数名
print(list(filter(str.islower,"Abcd")))

迭代器和可迭代对象的关系：
一个迭代器肯定是一个可迭代对象
可迭代对象可以重复使用，而迭代器是一次性的（用一次就会清空，类似于指针，内存空间是连续的，迭代完之后指针就指向空了）
可以通过iter()函数将可迭代对象转化为迭代器
next()函数可以逐个将迭代器的元素一一提取出来

# 初始化一个迭代器，只能用一次，就像遍历列表最后会指向空
a=filter(str.islower,"Abcd")
for i in a:
    print(i)
print(list(a))  #遍历迭代器最后是空

# 可迭代对象转为迭代器
a=iter([1,2,3])
# 遍历迭代器
print(next(a))
print(next(a))
print(next(a))
print(next(a,"没了"))

2.7 集合

2.7.1 集合的创建

集合所有的元素都是唯一的，并且是无序的（没有索引的概念，因此也无法按照列表那样，按照索引去查找集合中的某个元素）

无序与有序分别是如何在内存中实现存储的？

集合的创建方式如下：

  • 直接创建，用花括号包裹元素
  • 用集合推导式创建
  • 使用类型构造器set
a={"一","二","三"}
b={s for s in "123"}
# set()会对传入的可迭代对象进行迭代
c=set("123")
print(a,b,c)

集合的唯一性，可以实现一些去重操作

a=[1,2,3,4,3,4]
print(len(set(a))==len(a))

2.7.2 集合的方法

集合内置方法的对象可以是任何可迭代对象

# 浅拷贝
c=set("123")
d=c.copy()
print(d)
# 判断两个集合是否存在交集
e=set("345")
print(e.isdisjoint(c))
# 判断一个集合是否是另一个集合的子集
print(c.issubset("123456"))
# 判断一个集合是否是另一个集合的超集
print(c.issuperset("12"))
# 并集（可多参数）
print(c.union("0"))
# 交集（可多参数）
print(c.intersection("23456"))
# 差集（可多参数）
print(c.difference("3456"))
# 对称差集
print(c.symmetric_difference("234"))

以上方法都可以用运算符来实现，但是运算对象必须都是集合类型

c=set("123")
# 判断是否子集（运算符都要用集合类型）
print(c<=set("1234"))
# 判断是否是真子集
print(c<set("1234"))
# 判断是否是超集
print(c>=set("1234"))
# 判断是否是真超集
print(c>set("1234"))
# 并集
print(c|set("0"))
# 交集
print(c&set("23456"))
# 差集
print(c-set("3456"))
# 对称差集
print(c^set("234"))

在这里插入图片描述

2.7.3 可变集合与不可变集合

顾名思义，可变集合的元素可以改变，不可变集合的元素不可改变
可变集合可以用一些交集，差集，对称差集的方法改变其元素
但不可变集合不可改变

2.7.3.1 可变集合的增删改查
  • 增
a=set("123456")
b=frozenset("123456")
# 并集
c=set("123456")
c.update("0")
# 差集
d=set("123456")
d.difference_update("123")
# 交集
e=set("123456")
e.intersection_update("23456")
# 对称差集
f=set("123456")
f.symmetric_difference_update("234")
# add()方法和并集的差别是它是将整个内容插入集合，而不是迭代后再插入
g=set("123456")
g.add("99")
print(a,d,e,f,g)
  • 删
# 集合的删
a=set("123456")
# a.remove("0")
a.discard("0")
# 随机弹出一个元素
a.pop()
# 清空集合
a.clear()
print(a)

2.7.2 可哈希

整数的哈希值等于本身
两个对象是相等的，那么它们的哈希值也是相等的
可变的对象都是可哈希的，不可变的对象是不可哈希的
字典和集合的元素必须是可哈希的，也就是不可变的
集合的背后有散列表的支持，索引会很快，散列表也就是哈希表，但是对应也会占据海量存储空间（时空不可兼得）

2.8 字典

字典是Python中唯一实现映射关系的内置类型
映射关系是指两个
字典与序列最大的区别在于，序列是通过位置的偏移来存取数据，而字典是通过键来写入和读取数据（字典的存储顺序在3.7版本之前不一定像序列那样是按照顺序来的），字典的键是唯一的不可重复的

2.8.1 字典的创建

（1）字典长什么样

a={1:"一",2:"二",3:"三"} #冒号左边的是字典的键，冒号右边是字典的值
# 读取字典，方括号里面填写键的名称
print(a[1])
# 创建新的键值对,创建一个新的键并赋值
a[4]="4"
print(a)

（2）创建字典的几种方法

  • 直接用花括号创建有固定起始的键值对的字典
  • dict()函数生成字典
  • 使用列表作为字典的参数创建，列表中的每个元素是一个元组，用元组将映射关系包裹起来
  • 将第一种作为参数传到dict()函数中
  • 将第一种和第二种组合起来
  • 使用zip函数作为参数将两个列表组合成映射关系生成字典
a={1:"一",2:"二",3:"三"}              #键名可以用数值类型
b=dict(X1="一",X2="二",X3="三")       #键名不能用数值类型
c=dict([("X1","一"),("X2","二"),("X3","三")])
d=dict({1:"一",2:"二",3:"三"})        #键名可以用数值类型
e=dict({1:"一",2:"二"},X3="三")       #只有前面键名可以用数值类型
f=dict(zip([1,2,3],["一","二","三"])) #键名可以用数值类型
print(a,"\n",b,"\n",c,"\n",d,"\n",e,"\n",f)

在这里插入图片描述

2.8.2 字典的增删改查

2.8.2.1 增

单个增加：加入一个字典中不存在的键；同时增加多个：

# 创建一个值都为默认值的字典
a=dict.fromkeys(["X1","X2","X3"],0)
print(a)
a["X4"]="四"
print(a)
2.8.2.2 删

字典的内置pop函数，删除指定的键值对（参数是键），popitem函数删除字典最后加入的键值对（p3.7之前是随机删除一个键值对）；del函数删除字典的指定键值对，也可以直接删除字典；clear函数是清空字典内容

# 删指定键值对
a.pop("X1")
print(a)
# 删最后一个加入字典的键值对
a.popitem()
print(a)
# 清空键值对
a.clear()
print(a)
# 删除字典,也单独删除字典元素
del a["X4"]
del a
2.8.2.2 改

单个修改：对字典中已存在的键值对进行重新赋值；同时修改多个：update()函数通过更新字典修改或者通过更新字典的键的值进行修改

# 改
b=dict.fromkeys(["X1","X2","X3"],0)
# 直接修改
b["X1"]=1
print(b)
# 通过更新字典修改
b.update({"X2":2,"X3":3})
print(b)
# 通过更新字典的键的值进行修改
b.update(X4=4)
print(b)
2.8.2.4 查：

get函数和setdefault函数

c=dict.fromkeys(["X1","X2","X3"],0)
# 单纯查询，找不到返回default
print(c.get("X5","找不到"))
# 找不到值时，把新值增加到字典里
print(c.setdefault("X5",0))
print(c)

创建字典的动态视图，查询字典的键值对、键、值

d={'X1': 0, 'X2': 0, 'X3': 0, 'X4': 0}
items=d.items()
values=d.values()
keys=d.keys()
print(d,"\n",items,"\n",values,"\n",keys)
# 视图随着字典本身发生变化而变化
d.pop("X1")
print(d,"\n",items,"\n",values,"\n",keys)

字典的一些其他用法

d={'X1': 0, 'X2': 0, 'X3': 0, 'X4': 0}
# 字典的拷贝
f=d.copy()
# 查询字典键值对的数量
print(len(d))
# 字典的in运算,只能看键是否在字典里
print("X1" in d)

字典与列表的转换

# 将字典转为列表
print(list(d))
print(list(d.values()))
print(list(d.keys()))   #等价于list(d)
# 将字典转为迭代器,是将字典中的键转为迭代器
print(iter(d))

字典的排序

# 字典的倒置
d={'X1': 1, 'X2': 2, 'X3': 3, 'X4': 4}
# reversed函数返回迭代器
print(list(reversed(d)))
print(list(reversed(d.keys())))
print(list(reversed(d.values())))

2.8.3 字典的嵌套

嵌套字典，与嵌套列表类似

# 嵌套字典，与嵌套列表类似
d={'1班': {'女': 30, '男': 10}, '2班':{'女': 60, '男': 20}}
print(d["1班"]["女"])
# 嵌套可以字典和序列混着用
d={'1班': [30,10], '2班':[60,20]}
print(d["1班"][0])

2.8.4 字典推导式

d={'X1': 1, 'X2': 2, 'X3': 3, 'X4': 4}
print({V:K for K,V in d.items()})
print({V:K for K,V in d.items() if V>1})
print({x:ord(x) for x in "ABC"})
# 因为字典键的值是唯一的,而y是一直在变化的，先被赋值的被后赋值的替换掉了所以只取最后一个值
print({x:y for x in [1,2,3] for y in [4,5,6]})

在这里插入图片描述

3. 运算符

3.1 赋值运算符

 #赋值运算
temp=input("请输入一个整数：") #定义一个变量，使用input接收用户的输入值并返回这个值（此时值是字符串）
temp=int(temp)#将变量值强转为int类型
print(temp+2)

3.2 比较运算符

判断大小或相等
大于>、小于<、等于==、大于或等于>=、小于或等于<=

3.3 逻辑运算符

逻辑运算也叫布尔运算

  1. and：运算符两边操作数都要为True
  2. or：运算符两边操作数至少一个为True
  3. not：得到与操作数相反的结果

3.4 短路逻辑和运算符优先级

3.4.1 短路逻辑

从左往右，只有当第一个操作数的值无法确定逻辑运算的结果时，才对第二个操作数进行求值（Python中任何对象都能进行真值测试）

  1. and运算，两边都为真才为真：当第一个值为假，则直接输出第一个值，否则继续判断第二个值，并直接根据第二个值输出内容，第二个值为真输出真，第二值为假输出假（输出）
  2. or运算，两边只要有一个为真就为真：当第一个值为真，则直接输出第一个值，否则继续判断第二个值，并直接根据第二个值输出内容，第二个值为真输出真，第二值为假输出假**（输出第一个为真的值，若无则输出最后一个为假的值）**
  3. not运算，输出相反的逻辑运算结果
print(2 and 1 and 3) #全真：从左往右输出最后一个为真的值
print("" and 0 and 0) #全假：从左往右输出第一个为假的值
print(0 and 2 and "") #半真半假：从左往右输出第一个为假的值
print(2 and 1 and "") #半真半假：从左往右输出第一个为假的值
print(2 or 1 or 3) #全真：从左往右输出第一个为假的值
print("" or 0 or "") #全假：从左往右输出最后一个为假的值
print(0 or 2 or "") #半真半假：从左往右输出第一个为真的值
print(2 or 1 or "") #半真半假：从左往右输出第一个为真的值
print(not 1)
print(not "")
print(not 0)

在这里插入图片描述

3.4.2 运算符优先级

优先级从低到高的排序如下图：
在这里插入图片描述

4. 数据运算

除了基础的加减乘除运算，还有
（1）向下取整（地板除）
取比目标结果小的最大整数

a=-3//2

（2）幂运算

a=3**2

（3）一些内置BIF函数

  1. divmod(x,y)函数：同时求出两个参数地板除和求余数的值
  2. abs(x)函数：求对应参数的绝对值（如果传入的是复数就是复数的模）
  3. int(x)函数：将参数转换为整数（如果传入的是浮点数，得出的是截掉小数位的整数）
  4. float(x)函数：将参数转换为浮点数
  5. complex(x,y)函数：返回一个复数
  6. pow(x,y)函数：幂运算（可以传入第三个参数，会与前面两个参数得出的幂运算进行取余计算，相当于x ** y % z）
print(divmod(-7,2))
print(abs(3+4j))
print(int(3.56))
print(float("345"),float(345))
print(complex(3,4),complex("3+4j"))
print(pow(3,4),pow(3,4,5))

在这里插入图片描述

5. 基础的程序设计结构

5.1 分支结构

5.1.1 if 语法结构

age=16
if age<18:
    print("好的")

5.1.2 if else 语法结构

# 条件判断语句
num = input("请输入一个整数：")
num = int(num)
if num<3:
    print("小了")
else:
    print("大了")

5.1.3 if elif 语法结构

age=30
if age<18:
    print("未成年")
elif age>=18 and age<35:
    print("青壮年")
elif age>=35 and age<60:
    print("中老年")
elif age>=60:
    print("老年")

5.1.4 if elif else 语法结构

age=30
if age<18:
    print("未成年")
elif age>=18 and age<35:
    print("青壮年")
elif age>=35 and age<60:
    print("中老年")
else:
    print("老年")

5.1.5 if else的条件表达式

a=4
b=5
c=a if a<b else b
print(c)

score=90
level=("D" if 0<=score<60 else 
       "C" if 60<=score<70 else 
       "B" if 70<=score<80 else 
       "A" if 80<=score<100 else 
       "S" if score==100 else 
       "分数超100")
print(level)

5.1.6 分支结构的嵌套

# 两个条件判断嵌套
num = input("请输入一个整数：")
num = int(num)
if num<=3:
    if num==3:
        print("等于")
    else:
        print("小了")
else:
    print("大了")

5.2 循环结构

5.2.1 while循环

（1）如果条件为真时，执行循环体的内容
条件不能是永恒不变的为true，否则循环会一直执行

# 循环语句
temp=0 #设条件变量初始值
while temp<3: #注意冒号
    # 如果条件成立执行循环
    print("yes")
    temp=temp+1 #改变条件变量的值

在这里插入图片描述

（2）break跳出当前循环体

a=0
sum=0
# 执行2次循环
# 最后sum=0+0+1，a=0+1+1
while a<=2:
    sum += a
    a += 1
    if a==2: #当a为2时，跳出当前循环体
        break
print(a,sum)

（3）continue不执行下面的循环语句，跳回到循环开头

a=0
sum=0
# a=0
# 最后sum=0+0+1+2+3+4，a=0+1+1+1+1+1
while a<=2:
    sum += a
    a += 1
    if a==1:
        continue #当a等于1的时候不执行下面的语句，跳回开头
    print(sum,a)

在这里插入图片描述

a=0
sum=0
# 循环2次
# 最后sum=0+1+(跳)，a=0+1+1
while a<2:
    a += 1
    if a%2==0:
        print(a)
        continue #当a等于1的时候不执行下面的语句，跳回开头
    sum += a
    print(sum,a)

在这里插入图片描述

（4）与当前循环同级的else 可以检测循环是否完全执行
如果循环正常结束，则执行else下的语句；否则else也会被break打断。

day=1
while day<=3:
    answer=input("今天有好好学习吗？")
    if answer!="有":
        break
    day+=1
else:
    print("真棒！")

5.2.2 for循环

for循环语句对可迭代对象进行遍历循环
可迭代对象：元素能够单独被提起来的对象，比如字符串或列表里面的字母和数字等元素可以被一个个单独拿出来迭代

# range(10)生成一个从0-9的整数数列（10）指的是10个数
for a in range(10):
    print(a)

# range(2,10)生成一个从2-9的整数数列
for a in range(2,10):
    print(a)

# range(2,10,2)生成一个从2-9的整数数列，其跨度为2
for a in range(2,10,2):
    print(a)

# range(10,2,-2)生成一个从9-2的整数数列，其跨度为2（倒序）
for a in range(10,2,-2):
    print(a)

素数

for n in range(2,10):
    for i in range(2,n):
        if n%i==0:
            print(n,"不是素数")
            break
    else:
        print(n, "是素数")

5.2.3 循环结构嵌套

九九乘法表

# 九九乘法表
i=1
# 行的打印
while i<=9:
    j=1
    # 每一行的每列的打印
    while j<=i:
        print(i,"*",j,"=",i*j,end="  ")
        j+=1
    print() #执行完行的打印后换行
    i+=1

5.2.4 循环与分支结合

# 循环与分支结合
temp=0 #设循环语句条件中的变量初始值
while temp<3:
    # 如果条件成立执行下面循环
    num = input("请输入一个整数：")
    num = int(num)
    if num <= 3:
        if num == 3:
            print("等于")
            break
        else:
            print("小")
    else:
        print("大")
    temp=temp+1 #改变循环语句条件中的变量

在这里插入图片描述

6. 函数

6.1 创建函数

6.1.1 创建一个函数

函数有IDE自带的内置函数和自定义的函数
函数可以重复利用，可以将一个复杂的功能实现拆解为多个函数，解构功能

定义函数：def definition():需要执行的代码块
调用函数：调用函数名definition()
函数只有在定义或者调用的时候才会用到小括号

6.1.2 函数的参数

通过函数的参数实现功能的定制
函数的形式参数和实际参数：
形式参数是函数定义时写的参数，相当于变量名
实际参数是调用函数时传递给函数的值，相当于变量的值

6.1.3 函数的返回值

使用return语句，将函数实现之后返回某个值，调用这个函数，则获得这个返回的值（没有return语句的函数，也会最后执行完函数的所有语句之后返回一个none）
注意：只要存在return语句，函数就会立刻执行return语句，而不会管后面的语句

def chufa(a,b):
    # 执行了第一个return语句之后，函数不会再往下执行其他函数
    if b==0:
        return "除数不能为0"
    return a
print(chufa(6,0))

函数可以返回多个值，打包成元组输出

def function():
    return 1,2,3
print(type(function()))

6.2 函数参数的基本使用

参数是定制函数的接口，需要按照函数的要求传递正确的参数

6.2.1 位置参数

定义参数的时候，将参数的名字和位置定义下来，按顺序传递参数，来实现函数

def function1(a,b,c):
    return "".join((c,a,b))

print(function1("kill","它","你"))

6.2.2 关键字参数

通过关键字明确参数，参数的顺序不影响传递（默认参数必须在关键字参数之前）

# 定义参数的时候，已经将参数的名字和位置定义下来
def function1(a,b,c):
    return "".join((c,a,b))

print(function1(a="kill",b="它",c="你"))

6.2.3 默认值参数

给形参指定默认值，如果在调用函数的时候不写它的实参，那么就会取默认值，否则会取实参覆盖掉原来的默认值（默认参数应该放在最后）

def function1(a,b="吃",c="草莓"):
    return "".join((a,b,c))

print(function1(a="你"))

小技巧：使用help函数，查询各种内置函数的参数使用方法（查询出来的结果表示斜杠左边必须传入位置参数而不能是关键字参数）
print(help(sum))

在这里插入图片描述
因此在自定义的函数中也可以这样用
在参数中插入一个斜杠，可以限制斜杠左侧的是位置参数，后面的是关键字参数或者位置参数

def function1(a,/,b,c):
    return "".join((a,b,c))
print(function1("你",c="草莓",b="吃"))

类似的还有限制关键字的，在参数中插入一个星号，可以限制星号右侧的是关键字参数，左侧的是位置参数或者关键字参数

def function1(a,b,*,c):
    return "".join((a,b,c))
# 星号其实相当于收藏参数，后面实参不加参数名的话会被一起收过去
print(function1("你","吃",c="草莓"))

6.2.4 收藏参数

像print函数的参数一样，随便传几个就传几个的参数，为收藏参数
收藏参数其实是一组元组，收藏参数的形参是将多个参数打包到一个元组里面（元组具有打包和解包的作用）

# 定义收藏参数
def function2(*args):
    print("有{}个参数".format(len(args)))
    print("第一个参数是 {}".format(args[0]))
    print("第二个参数是 {}".format(args[1]))
function2("哈哈","呵呵")

收藏参数除了可以将参数打包为元组，还能将参数打包为字典

def function(**kwargs):
    print(kwargs)
function(a=1,b=2,c=3)

同时使用两种收藏参数（format()函数可以这样用）

# 同时使用两种收藏参数
def function(*args,**kwargs):
    print(args,kwargs)
function(1,1,2,3,a=1,b=2,c=3)

用dict构造 字典，键不能加引号

6.2.5 解包参数

在定义函数时，使用收藏参数是对形式参数的打包，那么在调用参数时，则可以对实际参数进行解包操作

args=(1,2,3)
def function(a,b,c):
    print(a,b,c)
# 对参数进行解包，将元组的元素拆分后传入函数
function(*args)

args={"x":1,"y":2,"z":3}
# 形参的名称与字典的键保持一致
def function(x,y,z):
    print(x,y,z)
# 对参数进行解包，将元组的元素拆分后传入函数的形参中
function(**args)

6.3 函数的作用域

6.3.1 局部作用域与全局作用域

如果一个变量定义的位置是在函数里面，那么它的作用域仅限于此函数
如果在任何函数的外部定义一个变量，那么它的作用域就是全局的

y=4   #全局作用域
def function():
    x=3  #局部作用域
    print(x,y)

def function1():
    function()
    print(y)
    
function1()

在函数中如果存在与全局变量名一样的局部变量，局部变量作用域会覆盖同名的全局变量的作用域（局部变量只作用于在函数内部），但是两个变量还是不同的变量。
也就是说，可以在函数内部中访问全局变量，但是无法对全局变量的值进行修改，一旦修改函数内部会创建一个同名的局部变量进行覆盖

在函数内修改全局变量
使用global在函数中声明全局变量，可以改变全局变量的值，但一般情况下不建议修改全局变量

y=4   #全局变量
def function():
    # 使用global在函数中声明全局变量，可以改变全局变量的值
    global y
    y=3  
    print(y)
function()
print(y)

6.3.2 嵌套函数

内部函数无法更改外部函数的变量

x=123
def funA():
    x=12
    print("A函数",x,id(x))
    def funB():
        x=21
        print("B函数",x,id(x))
    # 函数要在定义的下面才能调用
    funB()
# 此时的funA函数的x与funB的x已经不是同一个变量
print("全局",x,id(x))
funA()

在内部函数修改其外部函数的变量
使用nonlocal在内部函数中声明外部函数的变量，可以改变外部函数变量的值

x=123
def funA():
    x=12
    print("A函数",x,id(x))
    def funB():
        nonlocal x
        x=21
        print("B函数",x,id(x))
    funB()
    print("A函数修改后",x,id(x))
# 此时的funA函数的x与funB的x已经不是同一个变量
print("全局",x,id(x))
funA()

6.3.3 LEGB原则

L：local是局部作用域
E：enclosed是嵌套函数的外层函数作用域
G：global是全局作用域
B：build-in是内置作用域

局部作用域会覆盖全局作用域
在嵌套函数中，内部函数的局部作用域会覆盖外层函数的作用域

将内置函数设置为一个变量的时候，这个BIF就会被毁坏，变量名不要跟内置函数相同

6.4 闭包

6.5 装饰器

6.6 生成器

7. 异常

8. 类和对象

6. Python模块的使用

Python的库、包和模块的概念：
在python中，具有某些功能的模块和包都可以被称作库，模块有诸多函数组成，包由诸多模块机构化组成，库中也可以包含包、模块和函数。
>原文2

（1）模块的导入和使用
以random模块为例

import random #导入random模块
ans= random.randint(1,10) #调用random模块中的randint函数，随机生成1~10的整数
temp=0 #设循环语句条件中的变量初始值
while temp<3:
    # 如果条件成立执行下面循环
    num = input("请输入一个整数：")
    num = int(num)
    if num <= ans:
        if num == ans:
            print("等于")
            break
        else:
            print("小了")
    else:
        print("大了")
    temp=temp+1 #改变循环语句条件中的变量

  1. 原文来自：https://blog.csdn.net/qq_32727095/article/details/118106061 ↩︎

  2. 原文来自网络 ↩︎

某某某粥
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值