PyCharm的使用
- 在工程下文件中按shift+F6，修改文件名字
Python基础语法
字面量
- 代码中，被写下来的固定的值，被称为字面量，相当于c/c++中的常量
常用值的类型
| 类型 | 描述 | 说明 |
|---|---|---|
| 数字（Number） | 整数（int），浮点数（float），复数（complex），布尔（bool） | 复数（complex），如：4+3j，以j结尾表示复数 |
| 字符串（String） | 描述文本的一种数据类型 | 字符串（string）由任意数量的字符组成 |
| 列表（List） | 有序的可变序列 | Python中使用最频繁的数据类型，可有序记录一堆数据 |
| 元组（Tuple） | 有序的不可变序列 | 可有序记录一堆不可变的Python数据集合 |
| 集合（Set） | 无序不重复集合 | 可无序记录一堆不重复的Python数据集合 |
| 字典（Dictionary） | 无序Key-Value集合 | 可无序记录一堆Key-Value型的Python数据集合 |
注释
-
单行注释:
# 单行注释 -
建议在#号和注释内容之间，间隔一个空格
-
多行注释：
""" 多行注释 可以换行 """ -
通过一对三个引号来定义(“”“注释内容”“”)，引号内部均是注释，可以换行
变量
-
type函数查看数据的类型，返回值是该类型的字符串
-
name = 100; test = type(name); print(test); #输出结果： <class 'int'>
字符串
三种定义方式
-
双引号定义法：“字符串”
test = "你好" -
单引号定义法：‘字符串’
test1 = '你好' -
三引号定义法: “”“字符串”“”
test2 = """你 好啊啊啊啊""" -
三引号定义法，和多行注释的写法一样，同样支持换行操作。
使用变量接收它，它就是字符串
不使用变量接收它，就可以作为多行注释使用。
字符串的引号嵌套
-
单引号定义法，可以内含双引号
-
双引号定义法，可以内含单引号
-
可以使用转移字符（\）来将引号解除效用，变成普通字符串
print("'你好啊'") print( "\"加油鸭\"") print('"向前冲"') # 输出结果分别为： '你好啊' "加油鸭" "向前冲"
字符串拼接
直接使用+
-
直接使用+
name = "chen" print("你好啊"+name+"你要加油鸭") # 输出结果： 你好啊chen你要加油鸭- 直接使用+,无法和非字符串的数据进行拼接
age = 24; print("我的年龄是"+age) # 输出结果： TypeError: can only concatenate str (not "int") to str
使用字符串格式化
-
使用+和其他类型的类型的数据进行拼接，需要使用字符串的格式化
-
字符串的格式化类似于c语言中的占位符,多个变量占位变量要用括号括起来,并按照占位的顺序填入
name = "chen" age = 24 print("我的名字是%s,今年%d岁" %(name,age)) # 输出结果： 我的名字是chen,今年24岁 -
在此处整型或者浮点型数据的占位符也可以用%s来表示，只不过此时是先把变成字符串在合并
-
其对于浮点数的精度控制和C语言一样
-
可以使用辅助符号"m.n"来控制数据的宽度和精度
-
m，控制宽度，要求是数字（很少使用）,设置的宽度小于数字自身，不生效
-
.n，控制小数点精度，要求是数字，会进行小数的四舍五入
-
%5.2f：表示将宽度控制为5，将小数点精度设置为2
小数点和小数部分也算入宽度计算。如，对11.345设置了%7.2f 后，结果是：[空格] [ 空格]11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为 .35
print("超声波测距：%8.2f" % 11.323) # 输出结果： 超声波测距： 11.32 -
f"内容{变量}"的格式来快速格式化
-
这种写法不做精度控制,也不理会类型
name = "chen" age = 24.5 print(f"我是{name},我的年龄是{age}") #输出结果: 我是chen,我的年龄是24.5print(f"我是{'chen'},我的年龄是{12}") #输出结果和上面相同 -
表达式的格式化
- f"{表达式}"
- “%s%d%f” % (表达式、表达式、表达式）
数据类型转换
| 函数 | 说明 |
|---|---|
| int(x) | 将x转换为一个整数 |
| float(x) | 将x转换为一个浮点数 |
| str(x) | 将对象 x 转换为字符串 |
-
任何类型，都可以通过str()，转换成字符串
-
字符串内必须真的是数字，才可以将字符串转换为数字
-
浮点转整型直接舍去小数部分
标识符
- 用户编写代码时，对变量、类、方法等编写的名字，叫做标识符。
- 命名规则
- 内容限定（中文、英文、数字、下划线）
- 大小写敏感
- 不可使用关键字
运算符
和C语言不同的
-
/
-
除法，C/C++除法如果是整数相除但是除不尽，会舍去小数部分，但Python不会
print(5/2); #输出结果： 2.5
-
-
//
- 取整除 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
- 指数 2**3 其输出结果为8
复合赋值运算和C相同，例如+=，*=
数据输入input
-
使用input()语句可以从键盘获取输入
-
使用一个变量接收（存储）input语句获取的键盘输入数据即可
age = input("请告诉我你是谁：") # 输出结果： 请告诉我你是谁：king -
可以使用：input(提示信息)，用以在使用者输入内容之前显示提示信息。
-
无论键盘输入什么类型的数据，获取到的数据永远都是字符串类型
Python 判断语句
if else语句
-
靠缩进来控制范围，如果是第一个if判断需要执行的语句，则前面应填充4个空格
-
字符串可以直接来比较是不是相等
if "chen" == "chen": print("here") else: print("here1") # 输出结果： here -
else后面也要加：
if elif语句
-
elif可以写多个
-
判断是互斥且有序的，上一个满足后面的就不会判断了（和c语言中的else if 很相似）
if "chen" == "li": print("here") elif 2 == 2: print("here0") elif 1 != 2: print("here2") else: print("here1") # 输出结果： here0 -
随机数 random
import random num = random.randint(1,10) # 随机产生1~10的整数
Python 循环语句
while循环
-
空格缩进来控制条件作用的范围
-
while循环打印九九乘法表
- Python的print语句默认后面输出换行，在print语句中，加上 end=‘ ’即可输出不换行了
print("HELLO",end='') print("world",end='') # 输出结果： HELLOworld- 制表符： \t 效果等同于在键盘按下：tab按键，使多行字符串进行对齐
print("HELLO Python") print("worldc chen") print("HELLO\tPython") print("worldc\tchen") # 输出结果： HELLO Python worldc chen HELLO Python worldc chen """ 但是有时候效果也不好 """ print("HELLO Python") print("worldcgj chen") print("HELLO\tPython") print("worldcgj\tchen") # 输出结果： HELLO Python worldcgj chen HELLO Python worldcgj chen -
i = j = 1 while i <= 9: j = 1; while j <= i: print(f"{j}*{i}={j*i}\t",end='') j += 1 i += 1 print( ) # 输出结果： 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
for循环
-
for 临时变量 in 待处理数据集:
循环满足条件时执行的代码 -
从待处理数据集中，逐个取出数据赋值给临时变量
-
无法定义循环条件，只能被动取出数据处理，还需要注意空格缩进
name = "chen" for x in name: print(x) # 输出结果： c h e n
range语句
-
获得一个数字序列（可迭代类型的一种）
-
语法格式：
- range(num)
- 从0开始，到num结束（不含num本身）
- range(num1, num2)
- 从num1开始，到num2结束（不含num2本身）
- range(num1, num2, step)
- 从num1开始，到num2结束（不含num2本身），步长以step值为准
n=range(1,10,2) for x in n: print(x) # 输出结果： 1 3 5 7 9 - range(num)
for循环的变量作用域
-
临时变量，在编程规范上，作用范围（作用域），只限定在for循环内部
-
如果在for循环外部访问临时变量，实际上是可以访问到的，在编程规范上，是不允许、不建议这么做的
-
如果实在需要在循环外访问循环内的临时变量，可以在循环外预先定义
x = 0 n=range(1,10,2) for x in n: .... ....
for 循环实现九九乘法表
-
num = range(1,10) for x in num: i = range(1,x + 1) for y in i: print(f"{x}*{y}={x * y}\t",end='') if x != 9: print() # 输出结果： 1*1=1 2*1=2 2*2=4 3*1=3 3*2=6 3*3=9 4*1=4 4*2=8 4*3=12 4*4=16 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
break和continue
- 无论是while循环或是for循环，都是重复性的执行特定操作
- continue：跳过当前的循环，进入下一次循环
- break：跳出循环
- 只能作用在所在的循环上，无法对上层循环起作用
Python 函数
- 是组织好的，可重复使用的，用来实现特定功能的代码段
函数的定义及调用
-
def 函数名(传入参数): 函数体 return 返回值 # 函数的调用： 函数名(参数) -
参数，返回值不需要时可以省略
函数参数
-
函数定义中的参数，称之为形式参数
-
函数调用中的参数，称之为实际参数
-
函数的参数数量不限，使用逗号分隔开
-
传入参数的时候，要和形式参数一一对应，逗号隔开
def add(x, y): result = x + y return result
函数返回值
-
和c的使用几乎没有差别，不同的是c需要指出函数返回值的类型，但Python不需要
-
此外Python如果没有使用return语句，是有默认的返回值是None
- None，其类型是：<class ‘NoneType’>
- None表示：空的、无实际意义的意思
def add(x, y): print(f"{x+y}") n = add(3, 4) print(n) print(type(n),end='') # 输出结果： 7 None <class 'NoneType'>- 此外，None还可以有其他的用途
- 用在if判断
- 在if判断中，None等同于False
- 一般用于在函数中主动返回None，配合if判断做相关处理用于声明无内容的变量
def Heelo(x): if x == 0: return 1 return None n = Heelo(1) if not n: print("HELLO",end='')- 用于声明无内容的变量上
- 定义变量，但暂时不需要变量有具体值，可以用None来表示
name = None #和C中的NULL差不多
变量的作用域
-
局部变量：作用范围在函数内部，在函数外部无法使用
-
全局变量：在函数内部和外部均可使用
-
如何将函数内定义的变量声明为全局变量：
-
在函数内使用全局变量时，也要先使用global来进行声明
- 使global关键字，global 变量
def test(): global n n = 100 print(n,end='') # 输出结果： NameError: name 'n' is not defined """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" def test(): global n n = 100 test() print(n,end='') # 输出结果： 100
Python数据容器
定义
- 一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
分类
-
数据容器根据特点的不同，如：是否支持重复元素，是否可以修改是否有序，等分为5类，分别是：
列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）
列表
基本语法：
-
# 字面量 [元素1，元素2，元素3，......] # 定义变量 变量名称 = [元素1，元素2，元素3......] # 定义空列表 变量名称 = [] 变量名称 = list() # 嵌套列表的定义： my_list = [[1,2,3],["chen","jing","fast"]] my_list1 = [[1,2,3],['chen','jing','fast']] print(my_list) print(my_list1) # 输出结果： [[1, 2, 3], ['chen', 'jing', 'fast']] [[1, 2, 3], ['chen', 'jing', 'fast']] -
元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表
-
可以和数组一样，通过下标来索引
my_list = [[1,2,3],["chen","jing","fast"]] my_list1 = [[1,2,3],['chen','jing','fast']] print(my_list[0]) print(my_list1[1]) # 输出结果： [1, 2, 3] ['chen', 'jing', 'fast'] -
反向下标:从后向前，从-1开始，依次递减-1，-2，-3…
my_list = [[1,2,3],["chen","jing","fast"]] my_list1 = [[1,2,3],['chen','jing','fast']] print(my_list[-2]) print(my_list1[-1]) # 输出结果 [1, 2, 3] ['chen', 'jing', 'fast'] -
嵌套列表的下标，使用上面的负数也可以，详细的可见下面的例子
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aD7rZIz1-1665063036048)(E:\学习笔记\python\pythyon\嵌套列表下标.png)]
-
my_list = [[1,2,3],["chen","jing","fast"]] my_list1 = [[1,2,3],['chen','jing','fast']] print(my_list[-2][0]) print(my_list1[1][1]) # 输出结果 1 jing
列表的常用操作
-
列表提供了一系列的功能，也称为方法：
插入元素，删除元素，清空列表，修改元素，统计元素个数
-
查找某元素的下标
- 功能：查找指定元素在列表的下标，如果找不到，报错ValueError
my_list = [[1,2,3],["chen","jing","fast"]] my_list1 = [[1,2,3],['chen','jing','fast']] print(my_list.index(["chen","jing","fast"])) # 输出结果： 1- 嵌套列表整体可用，但是被嵌套的列表中的元素没有办法使用
-
列表的修改方法
- 和数组利用下标修改是一样的，可以通过下标的正标，反标均可以进行
my_list = [[1,2,3],["chen","jing","fast"]] my_list1 = [[1,2,3],['chen','jing','fast']] my_list1[1]=0 print(my_list1) # 输出结果： [[1, 2, 3], 0] -
插入元素
- 列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素
my_list = [1,2,3] my_list.insert(1,9) print(my_list) print(my_list[1]) my_list.insert(-1,12) print(my_list) print(my_list[-1]) # 输出结果： [1, 9, 2, 3] 9 [1, 9, 2, 12, 3] 3 -
追加元素
- 列表.append(元素)，将指定元素，追加到尾部
my_list = [1,2,3] my_list.append(9) print(my_list) # 输出结果 [1, 2, 3, 9] ******************************************************** my_list = [1,2,3] my_list.append([7,8,9]) print(my_list) # 输出结果： [1, 2, 3, [7, 8, 9]]- 列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部
my_list = [1,2,3] my_list.extend([7,8,9]) print(my_list) # 输出结果： [1, 2, 3, 7, 8, 9] -
删除元素：
- del 列表[下标]
- 列表.pop(下标)
my_list = [1,2,3] del my_list[0] print(my_list) my_list.pop(0) print(my_list) #输出结果： [2, 3] [3] -
删除某元素在列表中的第一个匹配项
- 列表.remove(元素)
-
清空列表内容
- 列表.clear()
-
统计某元素在列表内的数量
- 列表.count(元素)
-
统计列表内，有多少元素
- len(列表)
列表的遍历
-
while循环可以自定循环条件，并自行控制、
-
for循环不可以自定循环条件，只可以一个个从容器内取出数据
-
while循环可以通过条件控制做到无限循环
-
for循环理论上不可以，因为被遍历的容器容量不是无限的
-
案例：取出列表内的偶数
my_list = [1,2,3,4,5,6,7,8,9,10] new_list = [] i = 0 while i < len(my_list): if (my_list[i] / 2-my_list[i] // 2) == 0: new_list.append(my_list[i]) i += 1 print(new_list) # 输出结果： [2, 4, 6, 8, 10]
元组（tuple）
定义
-
元组同列表一样，都是可以封装多个、不同类型的元素在内。不同点在于：元组一旦定义完成，就不可修改
-
定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型
my_tuple = (1,2,2,3) # 不同数据类型 my_tuple1 = (1,"chen",3) # 只有一个数据 my_tuple2 = (1,) # 嵌套 my_tuple3 = ((1,3,3),("chen",)) # 定义空元组 1. my_tuple = () 2. my_tuple1 = tuple() -
当元组中有一个数据时，数据后面必须加逗号，否则会成字符串
元组的相关操作
-
通过下表访问，和列表是一样的，有正负两种方式
-
方法 作用 index() 查找某个数据，如果数据存在返回对应的下标，否则报错 count() 统计某个数据在当前元组出现的次数 len(元组) 统计元组内的元素个数 my_tuple = (1,2,"chen") print(my_tuple[2]) print(my_tuple.index("chen")) print(my_tuple.count("chen")) # 输出结果： chen 2 1 -
不可以修改元组的内容，否则会直接报错
-
可以修改元组内的list的内容（修改元素、增加、删除、反转等）
my_tuple = (1,2,[1,'fast','li']) print(my_tuple) my_tuple[2][1] = "jing" print(my_tuple) # 输出结果： (1, 2, [1, 'fast', 'li']) (1, 2, [1, 'jing', 'li']) -
但是不可以替换list为其它list或其它类型，其本质还是不可以修改元组元素的数据，但是可以修改元组数据里面的数据
my_tuple = (1,2,[1,'fast','li']) print(my_tuple) my_tuple[2] = [1,"jing",'li'] print(my_tuple) # 输出报错 -
元组遍历，和列表一样
字符串
字符串的定义
- 字符串是字符的容器，一个字符串可以存放任意数量的字符、
- 和其它容器如：列表、元组一样，字符串也可以通过下标进行访问
- 同元组一样，字符串是一个：无法修改的数据容器
字符串的操作
-
操作 说明 字符串[下标] 根据下标索引取出特定位置字符 字符串.index(字符串） 查找给定字符的第一个匹配项的下标 字符串.replace(字符串1, 字符串2) 将字符串内的全部字符串1，替换为字符串2,不会修改原字符串，而是得到一个新的 字符串.split(字符串) 按照给定字符串，对字符串进行分隔,不会修改原字符串，而是得到一个新的列表 字符串.strip()
字符串.strip(字符串)移除首尾的空格和换行符或指定字符串 字符串.count(字符串) 统计字符串内某字符串的出现次数 len(字符串) 统计字符串的字符个数 s = "cc uu kk jj" print(s.index("kk")) # 输出结果： 6 ************************************************************* s = "cc uu kk jj" m_s = s.replace("kk","你好") print(m_s) print(s) # 输出结果： cc uu 你好 jj cc uu kk jj ************************************************************** m_s = s.split("kk") print(m_s) print(type(m_s)) print(s) # 输出结果： ['cc uu ', ' jj'] <class 'list'> cc uu kk jj ************************************************************** # 仅仅是对字符串的首末位置 s = " cc uu kk jj " \ "" print(s.strip()) print(s) # 输出结果： cc uu kk jj cc uu kk jj s = "kkcc uu kk jj kk" print(s.strip("kk")) print(s) # 输出结果： cc uu kk jj kkcc uu kk jj kk
序列
定义
- 序列是指：内容连续、有序，可使用下标索引的一类数据容器
- 列表、元组、字符串，均可以可以视为序列。
序列切片
-
切片：从一个序列中，取出一个子序列
-
序列支持切片，即：列表、元组、字符串，均支持进行切片操作
-
语法：序列[起始下标:结束下标:步长]
-
起始下标表示从何处开始，可以留空，留空视作从头开始
-
结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
-
步长表示，依次取元素的间隔
-
步长1表示，一个个取元素
-
步长2表示，每次跳过1个元素取
-
步长N表示，每次跳过N-1个元素取
-
步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
-
-
此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）
my_list = [1, 2, 3, 4, 5] new_list = my_list[1:4] # 下标1开始，下标4（不含）结束，步长1 print(new_list) # 结果：[2, 3, 4] my_str = "12345" new_str = my_str[:4:2] # 从头开始，到下标4（不含）结束，步长2 print(new_str) # 结果："13" my_str = "12345" new_str = my_str[::-1] # 从头（最后）开始，到尾结束，步长-1（倒序） print(new_str) # 结果："54321" my_list = [1, 2, 3, 4, 5] new_list = my_list[3:1:-1] # 从下标3开始，到下标1（不含）结束，步长-1（倒序） print(new_list) # 结果：[4, 3] my_tuple = (1, 2, 3, 4, 5) new_tuple = my_tuple[:1:-2] # 从头（最后）开始，到下标1(不含)结束，步长-2（倒序） print(new_tuple) # 结果：(5, 3)
集合（set）
- 列表可修改、支持重复元素且有序
- 元组、字符串不可修改、支持重复元素且有序
- 集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序
定义：
-
列表使用：[]
-
元组使用：()
-
字符串使用：“”
-
集合使用：{}
s = {"ni","ni",12,12,13,48,"ni"} print(s) # 输出结果： {48, 12, 13, 'ni'} # 每一次运行输出的顺序并不一定是相同的，因为其是无序的 # 空集合 此处空集合定义只有这一种方式，不能直接使用 变量名称 = {}，因为这个定义的是空字典 变量名称 = set()
集合常用操作
-
编号 操作 说明 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(集合) 得到一个整数，记录了集合的元素数量
集合的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据（混装）
- 数据是无序存储的（不支持下标索引）
- 不允许重复数据存在
- 可以修改（增加或删除元素等）
- 支持for循环
字典，映射（dict）
定义
-
同样使用{}，不过存储的元素是一个个的：键值对，如下语法：
- 使用{}存储原始，每一个元素是一个键值对
- 每一个键值对包含Key和Value（用冒号分隔）
- 键值对之间使用逗号分隔
- Key和Value可以是任意类型的数据（key不可为字典）
- Key不可重复，重复会对原有数据覆盖
my_dic = {1 : "chen",2 : "li","chen" : 666} print(my_dic["chen"]) print(my_dic[1]) # 输出结果： 666 chen # 定义空字典 my_dict = {} my_dict = dict() # 字典的嵌套 my_dic = {1 : "chen",2 : "li","chen" : 666,3 : {"语文":100,"数学":123}} print(my_dic[3]) print(my_dic[3]["语文"]) # 输出结果： {'语文': 100, '数学': 123} 100
字典的常用操作
-
编号 操作 说明 1 字典[Key] 获取指定Key对应的Value值 2 字典[Key] = Value 添加或更新键值对 3 字典.pop(Key) 取出Key对应的Value并在字典内删除此Key的键值对 4 字典.clear() 清空字典 5 字典.keys() 获取字典的全部Key，可用于for循环遍历字典 6 len(字典) 计算字典内的元素数量 -
my_dic = {1 : "chen",2 : "li","chen" : 666,3 : {"语文":100,"数学":123}} keys = my_dic.keys() print(keys) for x in keys: print(x) print() for x in keys: print(x,my_dic[x]) # 输出结果： dict_keys([1, 2, 'chen', 3]) <class 'dict_keys'> 1 2 chen 3 1 chen 2 li chen 666 3 {'语文': 100, '数学': 123} -
对字典进行循环，因为其不支持下标志索引，所以不可以用while循环遍历
字典的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据
- 每一份数据是KeyValue键值对
- 可以通过Key获取到Value，Key不可重复（重复会覆盖）
- 不支持下标索引
- 可以修改（增加或删除更新元素等）
- 支持for循环，不支持while循环
数据容器对比总结
-
列表 元组 字符串 集合 字典 元素数量 支持多个 支持多个 支持多个 支持多个 支持多个 元素类型 任意 任意 **仅字符 ** 任意 Key：Value
Key：除字典外任意类型 Value：任意类型下标索引 支持 支持 支持 不支持 **不支持 ** 重复元素 支持 支持 支持 不支持 不支持 可修改性 支持 不支持 不支持 支持 支持 数据有序 是 是 是 否 否 使用场景 可修改、可重复的一批数据记录场景 不可修改、可重复的一批数据记录场景 一串字符的记录场景 不可重复的数据记录场景 以Key检索Value的数据记录场景
应用场景：
- 列表：一批数据，可修改、可重复的存储场景
- 元组：一批数据，不可修改、可重复的存储场景
- 字符串：一串字符串的存储场景
- 集合：一批数据，去重存储场景
- 字典：一批数据，可用Key检索Value的存储场景
数据容器的通用操作
-
在遍历上
- 5类数据容器都支持for循环遍历
- 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）
-
len(容器)
- 统计容器的元素个数
my_list = [1, 2, 3] my_tuple = (1, 2, 3, 4, 5) my_str = "itiheima" print(len(my_list)) # 结果3 print(len(my_tuple)) # 结果5 print(len(my_str)) # 结果7 -
max(容器)
- 统计容器的最大元素
my_list = [1, 2, 3] my_tuple = (1, 2, 3, 4, 5) my_str = "itiheima" print(max(my_list)) # 结果3 print(max(my_tuple)) # 结果5 print(max(my_str)) # 结果t -
min(容器)
- 统计容器的最小元素
my_list = [1, 2, 3] my_tuple = (1, 2, 3, 4, 5) my_str = "itiheima" print(min(my_list)) # 结果1 print(min(my_tuple)) # 结果1 print(min(my_str)) # 结果a -
通用类型转换
- list(容器)：将给定容器转换为列表
- str(容器)：将给定容器转换为字符串
- tuple(容器)：将给定容器转换为元组
- set(容器)：将给定容器转换为集合
-
排序
- sorted(容器, [reverse=True])，将给定容器进行排序，排序后都会得到列表（list）对象。
Python 函数进阶
函数多返回值
-
def test_return(): return 1,2 x,y = test_return() print(x,y) # 输出结果： 1 2 -
按照返回值的顺序，写对应顺序的多个变量接收即可
-
变量之间用逗号隔开
-
支持不同类型的数据return
函数多种传参方式
位置参数
- 调用函数时根据函数定义的参数位置来传递参数
- 传递的参数和定义的参数的顺序及个数必须一致
- 和C传参一样
缺省参数
-
缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）.
-
函数调用时，如果为缺省参数传值则修改默认参数值, 否则使用这个默认值
-
和C++默认参数几乎一样
关键字参数
-
函数调用时通过“键=值”形式传递参数.
-
-
函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
不定长参数
-
不定长参数也叫可变参数. 用于不确定调用的时候会传递多少个参数(不传参也可以)的场景
-
不定长参数的类型:
- 位置传递
- 传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递
- 关键字传递
- 参数是“键=值”形式的形式的情况下, 所有的“键=值”都会被kwargs接受, 同时会根据“键=值”组成字典
def test_return(* args): print(args) def test_return1(**kwargs): print(kwargs) test_return("nihao",6688) test_return1(name='CGE',AGE="9966") # 输出结果： ('nihao', 6688) {'name': 'CGE', 'AGE': '9966'} - 位置传递
匿名函数
函数作为参数
-
函数本身是可以作为参数，传入另一个函数中进行使用的。不能再传递其他参数了
-
将函数传入的作用在于：传入计算逻辑，而非传入数据。
def test1(count): print(count(2,3)) def count(x,y): return x + y test1(count) # 输出结果： 5 ************************************** def test1(count,5): # 此处会报语法错误 print(count(2,3)+5) def count(x,y): return x + y test1(count,5)
lambda匿名函数
-
def关键字，可以定义带有名称的函数
-
lambda关键字，可以定义匿名函数（无名称）
-
有名称的函数，可以基于名称重复使用。
-
无名称的匿名函数，只可临时使用一次。
-
匿名函数定义语法：
- lambda 传入参数：函数体（一行代码）
- 传入参数表示匿名函数的形式参数，如：x, y 表示接收2个形式参数
- 函数体，就是函数的执行逻辑，要注意：只能写一行，无法写多行代码
def test1(count): print(count(2,3)) test1(lambda x,y:x+y) # 输出结果： 5
扫一扫
314
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
