python有关函数
数据类型
1.number数字类型（int float bool complex）
1.0奠基部分：函数type和id
#type概念：获取变量的数据类型
res=type(intvar)
print(res)
#id概念：获取变量值的地址
res=id(intvar)
print(res)
1.1 int整数类型表示方法
#整型（正整数 0 负整数）即整数
intvar=20
print(intvar)
第一个：二进制整数型0b
#注意：只有0和1俩个值
intvar=0b101
print(intvar) #注意输出结果为默认十进制数
第二个：八进制整数型0o
#注意：只有0 1 2 3 4 5 6 7八个数字
intvar=0o234
print(intvar) #注意输出结果为默认十进制
第三个：十六进制整形0x
#注意：只有：有0 1 2 4 5 6 7 8 9 a b c d e f
intvar = 0xff
print(intvar)
1.2 float浮点型（小数）
#方式一
floatvar = 3.14
print(floatvar)
print( type(floatvar) )
#方式二 科学计数法
floatvar = 5.1e3 #5.1*10^3
print(floatvar)
print( type(floatvar) )
1.3 bool 布尔型（True False）
boolvar=True
print(boolvar)
print( type(boolvar) )
1.4complex 复数类型
''' 复数 = 实数 + 虚数 例子: 3 + 4j 实数: 3 虚数: 4j 如果有一个数,它的平方等于-1,那么这个数就是j,科学家认为有,表达一个高精度的类型 '''
#方式一
complexvar = 3 + 4j
print(complexvar)
print(type(complexvar))
#方式二
#书写方式：complex(实数,虚数) => 复数
complexvar = complex(3,4)
complexvar = complex(3,-4)
print(complexvar)
2.字符串类型str：用引号引起来的就是字符串
2.1转义字符：通过\来实现
##第一种：把有意义的字符变得无意义
给 最好的 加上引号
strvar = "大连是东北\"最好的\"旅游居住城市"
strvar = '大连是东北"最好的"旅游居住城市'
print(strvar)
##第二种：把无意义的字符变得有意义
#字符意义：
\n : 换行
\r\n: 换行
\t : 缩进(水平制表符)[标准上,一个缩进的距离是4个空格的大小]
\r : 把\r后面的所有字符拉到当前行行首
2.2字符串使用技巧
# (1) 用单引号引起来的字符串
strvar = '今天的海边,海水非常湛蓝'
print(strvar)
print(type(strvar))
# (2) 用双引号引起来的字符串
strvar = "大连是一座美丽的\n海滨城市"
strvar = "大连是一座美丽的\r\n海滨城市"
strvar = "海水退潮的时候\t会有不少海螺可以捡"
strvar = "大连啊大连\r我的故乡"
strvar = "大连啊\n大连\r我的故乡"
print(strvar)
# (3) 用三引号引起来的字符串 特征: 允许跨行
strvar = ''' 振兴东北亚'老革命'基地 振兴大连,"重振"雄风 """abc""" '''
print(strvar)
print( type(strvar) )
# (4) 元字符串 r"字符串" => 不转义字符,原型化输出字符串
pathvar = r"C:\abc\wangwen\ntt" #路径中\ntt，为了让系统表示路径，而不是转义字符，需要在前面添加r
print(pathvar)
# (5) 字符串的格式化
'字符串' % (值1,值2,值3)
%d => 整型占位符
%f => 浮点型占位符
%s => 字符串占位符
#例子：
# %d 整型占位符
strvar = "冯远昨天晚上买了%d个娃娃" % (5)
print(strvar)
# %2d 占2位,默认居右
strvar = "冯远昨天晚上买了%2d个娃娃" % (5)
print(strvar)
# %-2d 占2位,原字符串居左
strvar = "冯远昨天晚上买了%-2d个娃娃" % (5)
print(strvar)
# %f 浮点型占位符 (默认保留小数点后面6位)
strvar = "冯远昨天晚上买娃娃,花了%f元" % (50000.78)
print(strvar)
# %.2f 小数点后,保留2位,存在四舍五入的情况
strvar = "冯远昨天晚上买娃娃,花了%.2f元" % (50000.78)
strvar = "冯远昨天晚上买娃娃,花了%.1f元" % (50000.78)
strvar = "冯远昨天晚上买娃娃,花了%f元" % (50000)
print(strvar)
# %s 字符串占位符
strvar = "%s" % (89)
strvar = "%s" % ("冯远身体可真好呀~")
print(strvar,type(strvar))
#总结：综合案例(搞不清楚用哪个,就统一全用%s即可)
strvar = "今天是学习python的第%d天,同学们%s,学习了%.1f个小时" % (1,"感觉非常开心",3.5)
print(strvar)
3 列表list
特点：可获取,可修改,有序
3.1 定义一个空列表
lst=[]
print(lst,type(lst))
3.2 定义一个普通的列表
lst = [100,7.5,False,5-90j,"王闻大帅哥"]
#正向下标： 0 1 2 3 4
#反向下标： -5 -4 -3 -2 -1
#获取列表中的数据
res=lst[1]
print(res)
3.3 函数len 获取容器类型数据的长度（元素个数）
length=len(lst) #元数中最后一个值的下标=总长度-1
res=lst[length-1]
print(res)
#综合上述
res = lst[len(lst) - 1]
print(res)
3.4 修改列表当中的元素
lst[3] = "abc"
print(lst)
4 元组tuple
特点：可获取,不可修改,有序
4.1 定义一个空元组
tup = ()
print(tup , type(tup) )
4.2 定义一个普通的元组
tup=(9,"abs",2.33)
正向下标： 0 1 2
逆向下标：-3 -2 -1
#获取元组中的值
res=tup[2]
print(res)
4.3 注意事项
tup=(False) tup=(23) tup=(2.2) #这些都不是元组类型的，分别是bool int float类型
tup=False，或者tup=(False,) #逗号才是区分,是否是元组的标识符
print(tup, type(tup)
4.4 字符串类型的有序取值
#特点: 可获取,不可修改,有序
strvar = "abcde"
#正向下标： 0 1 2 3 4
#逆向下标：-5 -4 -3 -2 -1
res = strvar[2]
res = strvar[-3]
print(res)
5.集合set
作用：交差互补
特点：无序，自动去重
5.1 定义一个空的集合
setvar=set()
print(setvar,type(setvar))
5.2 定义一个普通的·集合·
setvar={
"未见"，"其名"，"先见齐声"}
print(setvar,type(setvar))
#注意：集合是无序的
setvar={
"未见"，"其名"，"先见齐声"，"其名"，"未见" }
print(setvar,type(setvar))
6.字典dict
特点：键值对存储的数据，看起来有序，实际无序
6.1 定义一个空字典
dic={
}
print(dic,type(dic))
6.2 定义一个普通字典
dic={
"top":"程咬金","middle":"甄姬","bottom":"鲁班七号","jungle":"刘备","support":"蔡文姬"}
#获取字典中的值
res=dic["middle"]
print(res)
#修改字典当中的元素
dic["jungle"]="孙悟空"
print(dic)
#注意事项：
""" 对字典的键 和 集合的值 必须是如下类型: Number(int float bool complex) str tuple ( 可哈希的数据类型 ) 不能是如下类型: list set dict ( 不可哈希的数据类型 ) 集合和字典在存储时,使用了哈希算法,哈希算法是典型的无序特征 为什么要使用哈希算法: 默认存储数据时,是一个随机的散状存储, 为了充分利用内存的空间,让数据均匀的分配在内存中,采取哈希算法; 3.6版本之后,对字典进行了优化,存储的时候还是通过哈希算法 但是在拿出来,读取数据的时,重新按照定义时的顺序做了一次排序 所以,看起来有序,实际上无序 """
# 1.字典的键
""" 字典的键一般推荐写法 : 使用变量命名的字符串 """
dic = {
0:"aaa",4.67:"bbb",True:"ccc",4+90j:"ddd","花和尚":"鲁智深",(1,2,3,4,5):"fff"}
print(dic , type(dic))
res = dic[(1,2,3,4,5)]
print(res)
# 2.集合的值
setvar = {
1,3.5,False,5+6j,"a","niha",(1,2,3,4) ,[5,6,7] }
print(setvar,type(setvar))
容器类型数据：str list tuple set dict
可哈希的类型有字符串，元组，列表
类型转换
-
```python
–>Number部分
int : 整型 浮点型 布尔类型 纯数字字符串
float: 整型 浮点型 布尔类型 纯数字字符串
complex: 整型 浮点型 布尔类型 纯数字字符串 (复数)
bool: ( 容器类型数据 / Number类型数据 都可以 ) -
```python
–>容器类型部分
str: ( 容器类型数据 / Number类型数据 都可以 )
list: 字符串 列表 元组 集合 字典
tuple: 字符串 列表 元组 集合 字典
set: 字符串 列表 元组 集合 字典 (注意:相同的值,只会保留一份)
dict: 使用 二级列表,二级元组,二级集合(里面的容器数据只能是元组)
1.number类型强制转换（int float bool complex）
-
强制转换成int类型
var1=26 var2=2.33 var3=True var4=9+j var5="1223" var6="caf4567" # 强制转换成int类型 res=int(var2) print(res) #结果为2 res=int(var3) print(res) #Ture=1 Flase=0 res=int(var5) print(res,type(res)) -
强制转换成float 类型
var1=26 var2=2.33 var3=True var4=9+j var5="1223" var6="caf4567" res=float(var1) print(res) #26.0 res=float(var3) print(res) #1.0 res=float(var5) print(res) #1223.0 -
强制转换成complex 类型
var1=26 var2=2.33 var3=True var4=9+j var5="1223" var6="caf4567" res=complex(var1) print(res) #26+0j res=complex(var2) print(res) #2.33+0j res=complex(var3) print(res) #1+0j res=complex(var5) print(res) #1223+0j -
强制转换成bool 类型
bool数据类型只有Ture和False俩种 因此转换成布尔类型为假的有十种情况 0 0.0 False 0j '' [] ( ) set() { } None #None一般用来初始化变量的，表达一个空的，什么也没有，是系统的关键字 res=bool(None) print(res) -
自动类型转换
转换方式：自动转换时，默认把低精度向高精度转换
精度级别：bool=>int=>float=>complex
# bool+int res=Ture+10 print(res) #1+10 # bool+float res=False+3.3 print(res) #0.0+3.3 # bool+complex res=True+1+2j print(res) #2+2j # int+float res=5+9.1 print(res) #14.1 # int+complex res=3+2+4j print(res) #5+4j # float+complex res=2.33+3+4j print(res) #5.33+4j2.容器类型的强制转换
-
强制转换成str
var1 = "我真的是个帅哥哥" var2 = [1,2,3] var3 = (4,5,6) var4 = { "a","b","c"} var5 = { "花和尚":"鲁智深","智多星":"吴用","母夜叉":"杜十娘"} var6 = 789 #特点为：单纯的在当前数据类型的两边,套上引号 -
强制转换成列表list
res = list(var1) res = list(var3) res = list(var4) res = list(var5) print(res , type(res)) ''' 如果是字符串,把字符串里面的元素一个一个拿出来,作为列表的新元素 如果是字典,只保留字典的键,舍弃值,形成新的列表 其他的数据类型,就是单纯的在当前数据类型的两边套上[] ''' #注意：如果为number，就不能转换为列表 -
强制转换成tuple
res = tuple(var1) res = tuple(var2) res = tuple(var5) print(res) """ 如果是字符串,把字符串里面的元素一个一个拿出来,作为元组的新元素 如果是字典,只保留字典的键,舍弃值,形成新的元组 其他的数据类型,就是单纯的在当前数据类型的两边套上() """ -
强制转换成set
res = set(var1) res = set(var2) res = set(var5) print(res) """ 如果是字符串,把字符串里面的元素一个一个拿出来,作为集合的新元素 如果是字典,只保留字典的键,舍弃值,形成新的集合 其他的数据类型,就是单纯的在当前数据类型的两边套上{} """ -
强制转换成字典dict
前提条件：是一个等长的二级容器，里面的元素是俩个 三种情况： (1)外面是列表,里面是等长的二级容器,元素个数两个 lst = [('a',1),('b',2),('c',3)] dic = dict(lst) print(dic) (2)外面是元组,里面是等长的二级容器,元素个数两个 tup = (('c',3),['f',4],{ 'aa',20}) # 集合的无序性会让20做键,aa做值,所以不要用 dic = dict(tup) print(dic) (3)外面是集合,里面是等长的二级容器,元素个数两个 setvar = { ('e',10),('z',20)} dic = dict(setvar) print(dic)总结：
int float complex bool str list tuple set dict 作用：初始化当前类型的变量 例子：res=() print(res)容器类数据分类
1.二级容器
#二级列表 lst=[1,3,3,[3,5,6]] #二级元祖 tup=(1,2,(3,4,5)) #二级集合 （字符串，元组，Number可以做集合的值） setvar={ 'a','w',('q','q')} #二级集合中的符号不能为大括号，只能写成小括号 #二级字典 dic={ 'a':"逢源","b":{ "c":"魏吉祥","d":"魏建敏"}} print(dic["b"]["d"])2.等长的二级容器
概念：要求里面的元素都是容器，容器里面的元素个数都得相同 例子： lst=[(2,3),(3,4)] tup=([2,2],(2,4),{ 4,5})3.四级容器
container = [1,2,3,4,5,(6,7,8,9,{ "a":1,"b":2,"c":[9,10,"bingo"]})] 如何获取bingo？ res=container[-1][-1]["c"]["-1"] print=(res)变量的缓存机制
局限性：在同一个文件，针对python3.6有效
# 对于Number： 1.对于整型而言，-5~正无穷范围内的相同值 id一致 2.对于浮点数而言，非负数范围内的相同值 id一致 3.布尔值而言,值相同情况下，id一致 4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外) # 对于容器部分： 5.字符串 和 空元组 相同的情况下，地址相同 6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]
-
python运算符
1. 算数运算符：+ - * / // % **
# // 地板除(保留商,整数,不进行四舍五入)
如果除数或者被除数含有小数,那么结果就是个小数,否则就是个整数
例如：res=22.2//5 print(res) #4
# % 取余
res = 81 % 7 #4
res = 81 % -7 #-3 => 4+(-7) = -3 (余数+除数)
res = -81 % 7 #3 => -4+7 = 3 (如果被除数是负数,那么余数身上也带负号)
res = -81 % -7 #-4 => -4 (被除数和除数都是负的,结果就是余数加负号)
# **幂运算
res=2**3 print(res)
2.比较运算符：> < >= <= == !=
注意：比较运算符只会产生俩种结果：Ture False
res = 5 >= 6 # False
res = 5 >= 5 # True
res = 9 == 9 # 一个等号是在做赋值操作,二个等号是在做比较,二比较的结果只有真或假
3.赋值运算符：= += -= *= /= //= %= **=
# +=
var1 = 10
var2 = 20
var1+=var2 # var1=var1+var2=30
# *=
var1 = 2
var2 = 3
var1 *= var2 # var1 = var1 * var2 = 6
print(var1)
# %=
var1 = 10
var2 = 7
var1 %= var2 # var1 = var1 % var2 = 3
print(var1)
4.成员运算符：in 和 not in （针对容器类型数据）
(1)对于字符串：要求字符串是一个连续的片段
例子：str
var = "好看的皮囊千篇一律,有趣的灵魂200来斤"
res = "好" in strvar
res = "千篇一律" not in strvar
res = "灵斤" in strvar
print(res)
(2)对于列表 元祖 集合
lst = ["冯源","魏吉祥","魏济敏","李泰岚","耿进"]
tup = ("冯源","魏吉祥","魏济敏","李泰岚","耿进")
setvar = {
"冯源","魏吉祥","魏济敏","李泰岚","耿进"}
res = "冯源" in lst
res = "魏济敏" not in tup
res = "耿进" in setvar
print(res)
(3)针对于字典：针对于字典中的键来判断
dic = {
"fy":"冯源","wjx":"魏吉祥","wjm":"魏济敏"}
res = "魏济敏" in dic #error
res = "wjm" in dic #ture
print(res)
5，身份运算符：is 和 is not （检查俩个数据在内存中是否是同一个值）
# 整型
var1 = -100
var2 = -100
res = var1 is var2
print(res)
# 浮点型 非负数范围内的相同值 id一致
var1 = 13.87
var2 = 13.87
res = var1 is not var2
print(res)
# 容器类型
var1 = (1,2,3)
var2 = (1,2,3)
res = var1 is not var2
print(res)
6.逻辑运算符：and or not
# and 逻辑与
'''全真则真,一假则假'''
res = True and True # True
res = True and False # False
res = False and True # False
res = False and False# False
print(res)
# or 逻辑或
"""全假则假,一真则真"""
res = True or True #True
res = True or False #True
res = False or True #True
res = False or False #False
print(res)
# not 逻辑非
"""真变假,假变真"""
res = not True
res = not False
print(res)
# 逻辑短路
""" # (1)True or print(111) # True or True => True # True or False => True # (2)False and print(333) # False and False => False # False and True => False """
res = 5 or 6
res = 5 and 6
print(res)
总结：逻辑的优先级
由高到底： () > not > and > or
例子：
res = 5 or 6 and 7 # 5 or 7 => 5
res = 5 and 6 or 7 # 6 or 7 => 6
res = not 5 or 6 and 7 # False or 6 and 7 => False or 7 => 7
res = not (5 or 6) and 7 # not 5 and 7 => False and 7 => False
res = 1<2 or 3>4 and 5<6 and 7>8 or 9<3
""" res = True or False and True and False or False res = True or False and False or False res = True or False or False res = True or False res = True """
res = 1>2 or 3<4 or 5>6 and 7<10 and 100>99
# res = False or True or False and True and True
# res = False or True or False and True
# res = False or True or False
# res = True or False
# res = True
print(res)
7.位运算符：& | ^ << >> ~
# & 按位与
var1 = 19
var2 = 15
res = var1 & var2
print(res)
""" 10011 -->19 01111 -->15 00011 => 3 """
# | 按位或
res = var1 | var2
print(res)
""" 10011 01111 11111 => 31 """
# ^ 按位异或
"""两个值不一样,返回True,否则返回假"""
res = var1 ^ var2
print(res)
""" 10011 01111 11100 => 28 """
# << 左移
res = 5 << 1 # 10 5 * 2的1次幂
res = 5 << 2 # 20 5 * 2的2次幂
res = 5 << 3 # 40 5 * 2的3次幂
res = 5 << 4 # 80 5 * 2的4次幂
res = 5 << 5 # 160 5 * 2的5次幂
print(res)
""" 00101 01010 左移动一位 10 10100 左移动二位 20 ... """
# >> 右移
res = 5 >> 1 # 2 5 // 2的1次幂
res = 5 >> 2 # 1 5 // 2的2次幂
res = 5 >> 3 # 0 5 // 2的3次幂
res = 5 >> 4 # 0 5 // 2的4次幂
print(res)
""" 00101 # 5 00010 # 右移动一位 2 00001 # 右移动一位 1 00000 # 右移动一位 0 """
# ~ 按位非 -(n+1)
res = ~-250
print(res)
总结：运算符的总结
""" 优先级最高的符号是 : ** 优先级最低的符号是 : = 整体优先级: 一元运算符 > 二元运算符 一元运算符 : 同一时间,只操作一个数字的是一元(- ~) 二元运算符 : 同一时间,只操作一个数字的是二元(+ - * / ...) 逻辑运算符: () > not > and > or 算数运算符: 先算乘除,再算加减 位运算符 : ( >> << ) > & > ^ > | 大的整体优先级顺序:(算位比身成逻) 算术运算符 > 位运算符 > 比较运算符 > 身份运算符(is is not) > 成员运算符(in not in) > 逻辑运算符 赋值运算符用来收尾,把等号右边的值算完之后,赋值给左侧 """
res = 5+5 << 6//3 is 40 and True
#res = 10 << 2 is 40 and True
#res = 40 is 40 and True
#res = True and True
#res = True
print(res)
# 让别人能看懂,最好加上括号
res = (5+5) << (6//3) is 40 and True
代码块
概念：以冒号作为开始，用缩进来划分相同的作用域，这个整体就是代码块
作用域：作用的范围
if 5==5:
print(123)
print(234)
if 5==7:
print(12)
print(345)
print(23)
print(345)
代码块的注意点：代码块前面的空白，要么全用\t(table键)，要么全用4个空格，不能混着用，
如果混用了，就会报错IndentationError缩进错误
if 10==10:
print(12) #--->\t
print(345) #--->4空格
流程控制
1.基本概念
流程：代码执行的过程
控制：对代码执行过程进行把控
三大结构：
(1) 顺序结构 : 从上到下代码依次执行
(2) 分支结构 : 细分成四类
(3) 循环结构 : while , for
分支结构：
(1) 单项分支
(2) 双项分支
(3) 多项分支
(4) 巢状分支
2.分支结构
#单项分支
如果条件表达式成立,就执行其中的代码块,否则不执行
if 条件表达式:
code1
code2
例子：
zhanglei = "科学家"
if zhanglei == "科学家":
print("一个月的薪资是80000")
#双项分支（二选一）
如果条件表达式成立,返回True,执行if其中的代码块，反之不成立,返回False,执行else其中的代码块
if 条件表达式:
code1
code2
else:
code3
code4
例子：
fengyuan = "富翁"
if fengyuan == "富翁":
print("开兰博基尼")
print("住豪华的大别墅")
print("喷香奈儿的香水")
print("穿皮毛一体的衣服")
print("身边都是美女,左拥右抱")
else:
print("吃黄豆配凉水")
print("一年四季不洗澡")
练习：
# input 等待用户输入, 输入的内容都是字符串;
# name = input("请输入您的姓名:")
# print(name,type(name))
account = input("请输入您的用户名:")
password = input("请输入您的密码:")
if account == "aaa" and password == "bbb":
print("登录网站成功")
else:
print("登录网站失败")
#多项分支（多选一）
if 条件表达式1:
code1
elif 条件表达式2:
code2
elif 条件表达式3:
code3
else:
code4
''' 执行顺序:先判断条件表达式1是否成立,成立执行对应的代码块code1,否则 判断条件表达式2是否成立,成立执行对应的代码块code2,否则 判断条件表达式3是否成立,成立执行对应的代码块code3,否则 执行最后的else 分支 满足一个条件,其他分支不执行 elif + 表达式 可以是0或者是多个 else 不加表达式 可以是0或者是1个 '''
例子：
youqian = False youfang = False youcar = False youyanzhi = True yutili = True
if youqian == True:
print("我要嫁给你1")
elif youfang == True:
print("我要嫁给你2")
elif youcar == True:
print("我要嫁给你3")
elif youyanzhi == True:
print("我要嫁给你4")
elif youtili == True:
print("我要嫁给你5")
else:
print("你是个好人~6")
练习：
height = float(input("请输入您的身高"))
if 1 <= height <= 1.5 :
print("小强~你在哪里")
elif 1.5 < height <= 1.7:
print("没有安全感")
elif 1.7 < height <= 1.8:
print("帅哥~留个电话")
elif 1.8 < height <= 2:
print("帅哥~介意多个女朋友么?")
else:
print("你没有合适的配偶")
#巢状分支 （(单项分支,双项分支,多项分支的互相嵌套)）
例如：
youqian = True youfang = True youcar = True youyanzhi = True youtili = False
if youqian == True:
if youfang == True:
if youcar == True:
if youyanzhi == True:
if youtili == True:
print("老娘嫁给你")
else:
print("你回去吃两个大腰子补一补再来")
else:
print("你呀去韩国整一整再来")
else:
print("你是个大好人~")
3. 循环结构
特点：减少冗余代码，提升代码效率
分类：while for
1.while
while 条件表达式:
code
执行逻辑：如果条件表达式成立,返回True,执行循环体中的代码块，反之不成立,返回False ,不执行其中 的代码块
例如：
方法一：
i = 1
total = 0
while i <= 100:
total += i # total = total + i
i+=1
print(total)
执行逻辑分析：
第一次循环
i = 1 1 <= 100 total += i => total = total + i => 0 + 1
i+=1 => i=2
第二次循环
i = 2 2 <= 100 total += i => total = total + i => 0 + 1 + 2
i+=1 => i=3
第三次循环
i = 3 3 <= 100 total += i => total = total + i => 0 + 1 + 2 + 3
i+=1 => i=4
以此类推...
当i = 101 101 <= 100 为False 循环终止
print(total)
total = 0 + 1 + 2 + 3 + ... + 100 = 5050
方法二：
i = 1
total = 0
flag = True
while flag:
total += i
i+=1
# 当i为101的时候,让循环终止
if i == 101:
flag = False
print(total)
练习1：
打印一行十个小星星*
辅助：帮助文档 查看print函数的使用文档 => help(print)
i = 0
while i < 10:
# 写上自定义的逻辑
print("*",end="")
i+=1
练习2：
#通过字符串拼接到一个变量的形式,打印一行十个小星星
strvar = ""
i = 0
while i<10:
strvar += "*" # strvar = strvar + "*"
i+=1
print(strvar)
执行逻辑：
strvar = '' + "*"
strvar = '*' + "*"
strvar = '**' + "*"
strvar = '***' + "*"
strvar = '****' + "*"
...
strvar = "*********"
练习3：打印一行十个小星星,奇数个打印★,偶数个打印☆
i = 0
while i<10: # 0 ~ 9 为10次
if i % 2 == 0:
print("★",end="")
else:
print("☆",end="")
i+=1
# 通过字符串拼接到一个变量的形式,打印一行十个黑白相间小星星
i = 0
strvar = ""
while i<10: # 0 ~ 9 为10次
if i % 2 == 0:
strvar += "★"
else:
strvar += "☆"
i+=1
print(strvar)
练习4：用一个循环打印十行十列的小星星
i = 0
while i<100:
# 打印星星
print("*",end="")
# 什么时候换行? 当9 19 29 39 ... 99
if i % 10 == 9:
# 换行
print()
i+=1
练习5：用一个循环打印十行十列隔列换色的小星星
i = 0
while i <100:
# 打印星星
if i % 2 == 0:
print("★",end="")
else:
print("☆",end="")
# 打印换行
if i % 10 == 9:
print()
i+=1
练习6：用一个循环打印十行十列隔行换色的小星星
i = 0
while i<100:
# 打印星星
if i // 10 % 2 == 0:
print("★",end="")
else:
print("☆",end="")
# 打印换行
if i % 10 == 9:
print()
i+=1
常用的功能
1.字符串的相关操作
(1) 字符串的拼接 +
strvar ="你好" + "交个朋友"
print(strvar)
strvar+="加个微信"
print(strvar)
(2) 字符串的重复 *
strvar="重要的事情说三遍"
res=strvar * 3
print(res)
(3) 字符串跨行拼接 \
strvar="wruoif"\
"tuyhjguji"
print(strvar)
(4) 字符串的索引
strvar="我爱你亲爱的哈尼"
正向： 0 1 2 3 4 5 6 7
逆向：-8 -7 -6 -5 -4 -3 -2 -1
res = strvar[2]
print(res)
(5) 字符串的切片：（截取）
格式：字符串[::] 完整格式：[开始索引:结束索引:间隔值]
(1)[开始索引:] 从开始索引截取到字符串的最后
(2)
(3)[开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1)
(4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取字符
(5)[:]或[::] 截取所有字符串
例如：
strvar="我爱你亲爱的老阿姨,见到你我就心慌"
1 [开始索引:] 从开始索引截取到字符串的最后
res=strvar[3:]
print(res)
2 [:结束索引] 从开头截取到结束索引之前
res = strvar[:6] # 我爱你亲爱的
print(res)
3 [开始索引:结束索引] 从开始索引截取到结束索引之前(结束索
res = strvar[6:9]
print(res) #老阿姨
4 [开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取字符
res = strvar[::3] # 0 3 6 9 12 15 18 21 ....
print(res) # 我亲老,你心
res = strvar[::-1] # -1 -2 -3 -4 -5 -6....
print(res)
5 [:]或[::] 截取所有字符
res = strvar[:]
print(res)
#五个例子的结果依次为：
亲爱的老阿姨,见到你我就心慌
我爱你亲
老阿姨
我亲老,你心
慌心就我你到见,姨阿老的爱亲你爱我
我爱你亲爱的老阿姨,见到你我就心慌
2.双向循环练习
（1）打印十行十列小星星
j = 0
while j < 10:
# 写上自定义的代码
# 负责打印星星 **********
i = 0
while i<10:
print("*",end="")
i+=1
# 打印换行
print()
j+=1
(2) 打印十行十列隔列换色小星星(两个循环)
i = 0
while i < 10:
# 写上自定义的逻辑
j = 0
while j<10:
if j % 2 == 0:
print("★",end="")
else:
print("☆",end="")
j+=1
# 打印换行
print()
i+=1
（3）打印十行十列隔行换色的小星星
i = 0
while i < 10:
# 写上自定义的逻辑
j = 0
while j<10:
if i % 2 == 0:
print("★",end="")
else:
print("☆",end="")
j+=1
# 打印换行
print()
i+=1
（4）99乘法表
方法一：
i = 1
while i <= 9:
# 打印表达式
j = 1
while j<=i:
# 写上表达式 谁*谁=谁
# "字符串" % (值1,值2,....)
print("%d*%d=%2d " % (i,j,i*j) ,end="" )
j+=1
# 打印换行
print()
i+=1
方法二 ：
i = 9
while i>=1:
# 打印表达式
j = 1
while j<=i:
# 写上表达式 谁*谁=谁
# "字符串" % (值1,值2,....)
print("%d*%d=%2d " % (i,j,i*j) ,end="" )
j+=1
# 打印换行
print()
i-=1
方法三 ：
i = 1
while i <= 9:
# (1) 打印空格
k = 9 - i
while k>0:
print(" ",end="")
k-=1
# (2) 打印表达式
j = 1
while j<=i:
print("%d*%d=%2d " % (i,j,i*j) ,end="" )
j+=1
# (3) 打印换行
print()
i+=1
方法四：
i = 9
while i >= 1:
# (1) 打印空格
k = 9 - i
while k>0:
print(" ",end="")
k-=1
# (2) 打印表达式
j = 1
while j<=i:
print("%d*%d=%2d " % (i,j,i*j) ,end="" )
j+=1
# (3) 打印换行
print()
i-=1
(5) 100~999 找出所有的吉利数字 111 222 333 345 654 ..
思考方法：
// 可以获取一个数的高位
% 可以获取一个数的低位
789
个数: 789 % 10 = 9
十位: 789 // 10 % 10 = 8
百位: 789 // 100 = 7
解答：
i = 100
while i<=999:
gewei = i % 10
shiwei = i // 10 % 10
baiwei = i // 100
# 111 222 333 444 ...
if shiwei == gewei and shiwei == baiwei :
print(i)
# 123 456 678 ...
elif shiwei == baiwei + 1 and shiwei == gewei - 1:
print(i)
#987 432 ..
elif shiwei == baiwei -1 and shiwei == gewei+1:
print(i)
i+=1
3.循环结构for
while 一般用来在复杂的逻辑操作中 for 一般用来遍历数据
# 遍历字符串
# strvar = "今天下午,天气不错,海边有风"
# for i in strvar:
# print(i)
# 遍历列表
# container = [1,2,3]
# 遍历元组
# container = (4,5,6)
# 遍历集合
# container = {7,8,9}
# 遍历字典 (默认遍历的数据时字典的键)
container = {
"a":1,"b":2,"c":3}
for i in container:
print(i)
# 遍历等长的二级容器
container = [ ("王健林","王思聪","王林宁") ,("马云","马云坤","张英"), ("王宝强","马蓉","宋小宝")]
for i in container:
print(i)
# 变量的解包
a,b = 1,2
a,b,c = [3,4,5]
a,b,c = ("王健林","王思聪","王林宁")
print(a,b,c)
# 遍历不等长的二级容器
container = [ ("王健林","王思聪","王林宁") ,("马云","马云坤"), ("王宝强",)]
for i in container:
for j in i:
print(j)
4.range 配合 for 使用
# 一个参数的情况 0~9
for i in range(10):
print(i)
# 二个参数的情况 1~7
for i in range(1,8):
print(i)
# 三个参数的情况 1 4 7
for i in range(1,10,3):
print(i)
# 10 7 4
for i in range(10,1,-3):
print(i)
练习题：
改写99乘法表
for i in range(1,10):
# 打印星星
for j in range(1,i+1):
print("%d*%d=%2d " % (i,j,i*j) ,end="" )
# 打印换行
print()
for i in range(9,0):
print(i)
5.循环结构常用的关键字：pass break continue
（1）pass 过（占位符）
if 5 == 5：
pass
（2）break 终止当前循环（一定在循环中）
# 错误的写法：
if 5 == 5 :
break
例如1：
打印1~10 ,遇到5就终止
i = 1
while i <= 10:
if i == 5:
break
print(i)
i+=1
例如2：
i = 1
while i<=3:
j = 1
while j<=3:
if j == 2:
break
print(i,j)
j+=1
i+=1
# continue 跳过当前循环,从下一次循环开始
例子1：打印1~10 , 跳过5
方法一：
i = 1
while i<=10:
if i == 5:
i+=1
continue
print(i)
i+=1
方法二：
for i in range(1,11):
if i == 5:
continue
print(i)
例如2：打印1~100,所有不含有4的数字
方法一：
i = 1
while i <= 100:
strvar = str(i)
if "4" in strvar:
i+=1
continue
print(i)
i+=1
方法二：
i = 1
while i<=100:
# 判断个位 或者 十位 含有4的 通通跳过
if i // 10 == 4 or i % 10 == 4:
i+=1
continue
print(i)
i+=1
6.字符串的格式化format
（1）顺序传参
strvar = "{}向{}开了一枪,银弹而亡".format("小君儿","小乔")
print(strvar)
（2）索引传参
strvar = "{1}向{0}开了一枪,银弹而亡".format("小君儿","小乔")
print(strvar)
（3）关键字传参
strvar="{who}在{where}{do}".format(who="危机"，where="北京"，do="旅游")
print（strvar）
（4）容器类型数据（列表或者元祖或字典）传参
strvar="{0[0]}拿起了大炮，向{1[0]}开枪".format(["韩朝晨","何凯"],("小君儿","小乔"))
print(strvar)
strvar="{group1[1]}拿起了ak47,向{group2[xq]}进行扫射,嘴里大喊:鸭子给".format(group1=["韩朝晨","何凯"],group2={
"xj":"小君","xq":"小乔"})
print(strvar)
format的填充符号的使用: < > ^
三个符号的意义：
^ 原字符串居中
> 原字符串居右
< 原字符串居左
书写格式 :{
who:*^10}
who: : 关键字
* : 填充的符号
^ : 填充的方向
10 : 填充的总个数(原字符串长度+填充符号的长度)
strvar = "{who:>>10}在{where}{do:!<10}{feel:#^10}".format(who="枫",where="火神山医院",do="大保健",feel="感觉身体被掏空")
print(strvar)
7.进制转换等特殊符号的使用（ :d :f 😒 :, ）
# :d 整型占位符 (强制要求类型是整型,否则会报错)
strvar = "冯远昨天晚上买了{:d}个风油精".format(3)
print(strvar)
# :3d 占3位
strvar = "冯远昨天晚上买了{:3d}个风油精".format(3)
print(strvar)
# :f 浮点型占位符 (强制要求类型是浮点型,否则会报错)
strvar = "冯远买一瓶风油精,花了{:f}钱".format(98.123)
# :.2f 小数点保留两位
strvar = "冯远买一瓶风油精,花了{:.2f}元".format(98.123)
print(strvar)
# :s 字符串占位符
strvar = "{:s}".format("111222333")
print(strvar)
# :, 金钱占位符
strvar = "{:,}".format(123456789)
print(strvar) # 123,456,789
8.字符串的相关函数
# capitalize 字符串首字母大写
strvar = "you are the zhanan"
res = strvar.capitalize()
print(res)
# title 每个单词的首字母大写（非字母隔开的单词）
strvar = "you are the*zhanan"
res = strvar.title()
print(res)
# upper 将所有字母变成大写
strvar="you are the zhiMan"
res = strvar.upper()
print(res)
#lower 将所有字母变成小写
res = strvar.lower()
print(res)
# swapcase 大小写互换
res = strvar.swapcase()
print(res)
# count 统计字符串中某个元素的数量
strvar = "是生还是死,这的确是个问题"
res = strvar.count("是")
print(res)
# find 查找某个字符串第一次出现的索引位置
书写格式：find(字符串,[开始索引,结束索引]) 推荐使用find
strvar = "oh father this is my favorite boy"
res = strvar.find("father")
res = strvar.find("f",5) # 找f , 从索引号为5的地方开始找
# 如果find找不到 直接返回-1
res = strvar.find("f",5,10) # 从5~9
print(res)
# index
index 与 find 功能相同 find找不到返回-1,index找不到数据直接报错
res = strvar.index("f",5,10) # 从5~9
# startswith 判断是否以某个字符或者字符串为开头，返回Ture或者False
书写格式：startswith(字符串,[开始索引,结束索引]
strvar = "oh father this is my favorite boy"
res = strvar.startswith("oh")
res = strvar.startswith("father",3)
print(res)
# endswith 判断是否以某个字符或字符串结尾
res = strvar.endswith("boy")
res = strvar.endswith("ite",1,29)
print(res)
# split 按某字符将字符串分割成列表(默认字符是空格)
strvar = "you can you up no can no bb"
lst = strvar.split()
print(lst)
strvar = "you|can|you|up|no|can|no|bb"
lst = strvar.split("|")
print(lst)
# join 按某字符将列表拼接成字符串(容器类型都可)
lst = ['you', 'can', 'you', 'up', 'no', 'can', 'no', 'bb']
strvar = ' '.join(lst) # 按照空格这个字符对列表进行拼接 => 字符串
print(strvar)
# replace 替换字符串(可选择替换的次数)
书写格式：replace(原字符串,替换之后的字符串,[替换次数])
strvar = "可爱的小狼狗喜欢吃肉,有没有,有没有,还有没有"
res = strvar.replace("有没有","真没有")
print(res)
res = strvar.replace("有没有","真没有",1)
print(res)
# isdecimal 检测字符串是否以数字组成 必须是纯数字
strvar = "abc123"
strvar = "999888"
res = strvar.isdecimal()
print(res)
# strip 默认去掉首尾两边的空白符
strvar = " 刘德华 "
res = strvar.strip()
strvar = "@@@@@刘德华"
res = strvar.strip("@")
print(res)
# center 填充字符串,原字符居中 (默认填充空格)
strvar = "abc"
res = strvar.center(10,"*")
print(res)
例子结果：
You are the zhanan
You Are The*Zhanan
YOU ARE THE ZHIMAN
you are the zhiman
YOU ARE THE ZHImAN
3
-1
True
True
['you', 'can', 'you', 'up', 'no', 'can', 'no', 'bb']
['you', 'can', 'you', 'up', 'no', 'can', 'no', 'bb']
you can you up no can no bb
可爱的小狼狗喜欢吃肉,真没有,真没有,还真没有
可爱的小狼狗喜欢吃肉,真没有,有没有,还有没有
True
刘德华
***abc****
列表的相关函数
###增
1.append ：向列表的末尾添加新的元素
lst = ["枫"]
lst.append("小乔")
print(lst) # ['枫', '小乔']
2.insert ：在指定索引之前插入元素
lst = ['枫', '小乔']
lst.insert(1,"小君")
print(lst) # ['枫', '小君', '小乔']
3.extend ：迭代追加所有元素
lst = ['枫', '小君', '小乔']
lst_new = ["韩朝晨","何凯"]
lst.extend(lst_new)
print(lst) #['枫', '小君', '小乔', '韩朝晨', '何凯']
### 删
lst=["咣咣多多","韩朝晨","月尬勇"]
1.pop ：通过指定索引删除元素，若没有索引移除最后那个（推荐）
# 默认不加索引号,删除最后一个
# res = lst.pop()
# 指定索引进行删除
res = lst.pop(1)
print(res) # 韩朝晨
print(lst) # ['咣咣多多', '月尬勇']
2.remove ：通过给与得值来删除，如果多个相同的元素，默认删除第一个
lst = ["咣咣多多","韩朝晨","月尬勇"]
lst.remove("月尬勇")
print(lst) #['咣咣多多', '韩朝晨']
3.clear ：清空列表
lst=["咣咣多多","韩朝晨","月尬勇"]
lst.clear()
print(lst) # []
### 改 查
1.index : 获取某个值在列表中的索引
lst=["咣咣多多","韩朝晨","月尬勇"]
res = lst.index("韩朝晨") # 如果这个值不存在,直接报错
print(res) # 1
2.count : 计算某个元素出现的次数
lst = ["咣咣多多","韩朝晨","月尬勇","月尬勇","月尬勇","月尬勇"]
res = lst.count("月尬勇")
print(res)
3.sort ： 列表排序（默认小到大排序）
lst = [-90,100,4,20,1]
lst.sort()
print(lst) # [-90, 1, 4, 20, 100]
如果想实现从大到小排序可以使用reverse=True 是逆序
lst.sort(reverse=True)
print(lst) # [100, 20, 4, 1, -90]
# 对字母进行排序(参照ascii编码)(一位一位的比较)
lst = ["j","james","huohuade","oneal","jianeite","jiaodan","yao"]
lst.sort()
print(lst) #['huohuade', 'j', 'james', 'jianeite', 'jiaodan', 'oneal','yao']
4.reverse 功能：列表反转操作
lst = [1,2,"a",3]
lst.reverse()
print(lst) #[3, 'a', 2, 1]
5. tuple 里面只有2个函数 index count 用法和列表的一样;
深拷贝和浅拷贝
两者区别：
浅拷贝： 只能够 拷贝一级容器中所有的元素,独立出一份
深拷贝： 把所有层级的容器数据,全部单独拷贝一份
书写格式:
copy.copy() 浅拷贝
copy.deepcopy() 深拷贝
浅拷贝例子解释：
方法一：
lst1 = [1,2,3]
lst2 = copy.copy(lst1)
lst1.append(4)
print(lst1)
print(lst2)
方法二：
lst1 = [1,2,3]
lst2 = lst1.copy()
lst1.append(4)
print(lst1)
print(lst2)
深拷贝例子解释：
问题产生：lst二级列表不能赋值给lst_new
lst = [1,2,3,4,[5,6,7]]
lst_new = copy.copy(lst)
lst[-1].append(888)
print(lst)
print(lst_new)
利用深拷贝可以实现
lst = [1,2,3,4,[5,6,7]]
lst_new = copy.deepcopy(lst)
lst[-1].append(888)
print(lst)
print(lst_new)
字典的相关函数
### 增
方法一：
dic={
}
dic["top"]="weijis"
dic["middle"]="weight"
print(dic) #{'top': 'weijis', 'middle': 'weight'}
方法二：不推荐
#fromkeys() 使用一组键和默认值创建字典
# 对字典的键进行初始化
lst = ["a","b","c"]
dic = {
}.fromkeys(lst,None)
print(dic)
### 删
1.pop() :通过键去删除键值对 (若没有该键可设置默认值,预防报错)
dic = {
"top":"the_shy" , "middle":"rookie","bottom":"ww"}
# 指定字典的键来进行删除
res= dic.pop("top")
print(res) # the_shy
print(dic) #{'middle': 'rookie', 'bottom': 'ww'}
# 可以为当前不存在的键,设置默认值
res = dic.pop("abc","抱歉老弟,这个键真没有")
print(res) #抱歉老弟,这个键真没有
2.popitem() :删除最后一个键值对
res = dic.popitem()
print(res) #('bottom', 'ww')
print(dic) #{'middle': 'rookie'}
3.clear() :清空字典
dic = {
"top":"the_shy" , "middle":"rookie","bottom":"ww"}
dic.clear()
print(dic) # {}
### 改
1.update() :批量更新（有该键就更新，没有该键就增加）
dic = {
"top":"the_shy" , "middle":"rookie","bottom":"ww"}
dic_new = {
"jungle":"fpx_小天","support":"mata","bottom":"jacklove"}
dic.update(dic_new)
print(dic) # {'top': 'the_shy', 'middle': 'rookie', 'bottom': 'jacklove', 'jungle': 'fpx_小天', 'support': 'mata'}
### 查
1.get() :通过键获取值(若没有该键可设置默认值,预防报错)
dic = {
"top":"the_shy" , "middle":"rookie","bottom":"ww"}
res = dic.get("bottom12345")
res = dic.get("bottom12345","这个键真没有") # 可以给不存在的键设置默认值
print(res) # 这个键真没有
字典中重要的函数
1.keys() : 将字典的键组成新的可迭代对象(可以获取字典的键，组成列表形式)
dic = {
'top': 'the_shy', 'middle': 'rookie', 'bottom': 'jacklove', 'jungle': 'fpx_小天', 'support': 'mata'}
res = dic.keys()
print(res) # dict_keys(['top', 'middle', 'bottom', 'jungle', 'support'])
2.values() ：将字典中的值组成新的可迭代对象（可以获取键得值，组成一个列表）
res = dic.values()
print(res) #dict_values(['the_shy', 'rookie', 'jacklove', 'fpx_小天', 'mata'])
3.items() 将字典的键值对凑成一个个元组,组成新的可迭代对象
res = dic.items()
print(res) #dict_items([('top', 'the_shy'), ('middle', 'rookie'), ('bottom', 'jacklove'), ('jungle', 'fpx_小天'), ('support', 'mata')])
应用例子：
dic = {
'top': 'the_shy', 'middle': 'rookie', 'bottom': 'jacklove', 'jungle': 'fpx_小天', 'support': 'mata'}
for i in dic.items():
print(i)
打印结果为：
('top', 'the_shy')
('middle', 'rookie')
('bottom', 'jacklove')
('jungle', 'fpx_小天')
('support', 'mata')
通过items 来获取字典中的键值对
for k,v in dic.items():
print(k,v)
打印结果：
top the_shy
middle rookie
bottom jacklove
jungle fpx_小天
support mata
集合的相关操作
set1 = {
"刘德华","张学友","郭富城","王闻"}
set2 = {
"王力宏","王宝强","王健林","王闻"}
1. intersection交集
res = set1.intersection(set2)
print(res) # 王闻
简写形式：&
res=set1 & set2
print(res)
2.差集 difference
res = set1.difference(set2)
print(res) # {'郭富城', '张学友', '刘德华'}
简写形式：-
res = set1 - set2
print(res)
3.并集 union
res = set1.union(set2)
print(res) # {'郭富城', '王宝强', '刘德华', '王闻', '王力宏', '张学友', '王健林'}
简写形式：|
res = set1 | set2
print(res)
4.对称差集 symmetric_difference()
res = set1.symmetric_difference(set2)
print(res)
简写形式：^
set1 = {
"a","b","c"}
set2 = {
"a","e"}
res = set1 ^ set2
print(res) # {'c', 'b', 'e'}
5.issubset() 判断是否是子集
set1 = {
"王文","王健林","王大佬"}
set2 = {
"王大佬"}
res = set2.issubset(set1)
print(res) # True
6.issuperset() 判断是否是父集
res = set1.issuperset(set2)
print(res) #True
简写形式：< >
res = set1 > set2 #(判断大小来决定是不是子集或者父集)
print(res) #True
res = set1 <= set2
print(res) #False
7.isrdisjoint() 检测两集合是否不相交 不相交 True 相交False
es = set1.isdisjoint(set2)
print(res) # False
集合的相关函数
### 增
1.add() 向集合中添加数据(一次加一个)
setvar = {
"王文","周杰伦","邓紫棋"}
setvar.add("韩朝晨")
print(setvar) #{'周杰伦', '王文', '韩朝晨', '邓紫棋'}
2.update() 迭代着增加(一次加一堆)
lst = ["赵丽颖","迪丽热巴"]
setvar.update(lst)
print(setvar) #{'王文', '韩朝晨', '迪丽热巴', '邓紫棋', '周杰伦', '赵丽颖'}
### 删除
1.clear() 清空集合
setvar = {
"王文","周杰伦","邓紫棋"}
setvar.clear()
print(setvar) #set()
2.pop() 随机删除集合中的一个数据
setvar = {
"枫","魏吉祥","咣咣哆哆"}
res = setvar.pop()
print(res) #{'枫'}
print(strvar) #{"魏吉祥","咣咣哆哆"}
3.remove() 删除集合中指定的值(不存在则报错)
setvar = {
"枫","魏吉祥","咣咣哆哆"}
setvar.remove("枫")
print(setvar) # {'魏吉祥', '咣咣哆哆'}
4.discard() 删除集合中指定的值(不存在的不删除 推荐使用)
setvar = {
"枫","魏吉祥","咣咣哆哆"}
setvar.discard("枫1234")
print(setvar) #{'魏吉祥', '咣咣哆哆','枫'}
函数的使用
基本概念
功能：包裹一部分代码,实现某一个功能 达成某一个目的
特点：可以反复调用,提高代码的复用性,提升开发效率,遍于后期的维护
基本格式
定义一个函数：
def 函数名():
code1
code2
函数的调用：
函数名()
例如：
函数定义处：
def func():
print("我是枫")
函数的调用：
func()
应用：答应十个99乘法表
# 函数的定义
def chengfabiao_99():
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%2d " % (i,j,i*j) , end="" )
print()
# 函数的调用
for i in range(10):
chengfabiao_99()
函数的命名规则
字母数字下划线,首字符不能为数字
严格区分大小写,且不能使用关键字
函数命名有意义,且不能使用中文哦
驼峰命名法：
(1) 大驼峰命名法:每个单词的首字符都是大写 (面向对象当中,定义类) mycar => MyCar
(2) 小驼峰命名法:除了第一个单词的首字符小写外,剩下都大写 (函数 变量) mycar => myCar
命名一个函数 , 可以用下划线拼接单词的形式来组合
mycar => my_car symmetric_difference
函数的参数（餐数就是配合函数运行时，用到的值）
参数的种类：
(1)形参: 形式上的参数 , 在函数的定义处
(2)实参: 实际上的参数 , 在函数的调用处
形参的种类:
普通(位置)形参,默认形参,普通收集形参,命名关键字形参,关键字收集参数
实参的种类:
普通实参,关键字实参
注意点：调用参数的时候,形参和实参必须一一对应,否则报错
（1）普通形参
函数的定义处：
hang , lie 是普通形参
def star(hang,lie):
i=0
while i<hang:
j=0
while j<lie:
print("*",end="")
j+=1
print()
i+=1
函数的调用处：括号中数字为实参
star（10,10）
star（1.10）
(2) 默认形参：hang和lie身上带有默认值
函数定义：
def star(hang=10,lie=10):
i = 0
while i<hang:
j = 0
while j<lie:
print("*",end="")
j+=1
print()
i+=1
函数调用：
调用时,如果不给实参,
则使用参数身上的默认值
调用时,如果给参数,
则使用实际参数
star()
star(3,8)
(3) 普通形参 + 默认形参
注意点：默认参数必须跟在普通参数的后面
def star(hang,lie=10):
i = 0
while i<hang:
j = 0
while j<lie:
print("*",end="")
j+=1
print()
i+=1
star(5)
star(2,9)
(4)关键字实参
注意点：调用函数时，关键字实参顺序可以任意的调整
def star(hang,lie=10):
i = 0
while i<hang:
j = 0
while j<lie:
print("*",end="")
j+=1
print()
i+=1
# 关键字实参
star(hang=4,lie=8)
star(lie=8,hang=4)
(5) 普通实参 + 关键字实参
注意点：关键字实参必须跟在普通实参的身后
def star(hang,a,b,c,lie=10):
i = 0
while i<hang:
j = 0
while j<lie:
print("*",end="")
j+=1
print()
i+=1
# star(hang = 2,a=3,b=4,c=5,lie=6)
# star(2,b=2,c=3,lie=4,a=1)
star(1,2,b=3,c=3,lie=4)
收集参数
1.普通收集参数:专门用来收集那些多余的没人要的普通实参,收集之后,形成一个元组
语法：
def func(*args):
code
args => arguments
def func(a,b,*args):
print(a,b)
print(args)
func(1,2,3,4,5,65)
# 结果为：
1 2
(3, 4, 5, 65)
应用：计算任意长度的累加和
def func(*args):
total = 0
# print(args)
for i in args:
total += i
print(total)
func(1,2,3,4,5,6,7) #28
2.关键字收集参数:专门用来收集那些多余的没人要的关键字实参,收集之后,形成一个字典
语法：
def func(**kwargs):
code
kwargs => keyword arguments
def func(a,b,**kwargs):
print(a,b)
print(kwargs)
func(b=10,a=20,c=30,d=40,f=50)
结果为：
20 10
{
'c': 30, 'd': 40, 'f': 50}
应用：拼接任意长度的字符串
def func(**kwargs):
strvar1 = ''
strvar2 = ''
dic = {
"monitor":"班长","class_flower":"班花"}
# 遍历字典时,默认获取的键
for k,v in kwargs.items():
# 判断键是否在字典当中,如果在,获取字符串
if k in dic:
# 拼接字符串,讲两次循环的内容通过+号拼接在一起
strvar1 += dic[k] + ':' + v + "\n"
else:
# 拼接字符串, 拼的是吃瓜的人员
strvar2 += v + " "
print(strvar1)
print("吃瓜群中有:",strvar2)
func(monitor="小君儿",class_flower="小乔儿",eatgua1="光光多多",eatgua2="魏吉祥")
命名关键字参数
定义方式：
(1) def func(a,*,b) 跟在*号后面的参数为命名关键字参数
(2) def func(*args,b,**kwargs) 夹在普通收集和关键字收集参数之间的叫做命名关键字参数
强制在调用函数时,必须使用关键字实参
定义方法1
def func(a,b,*,c,d):
print(a,b)
print(c,d)
func(1,2,c=3,d=4)
# 定义方法2
def func(*args,b,**kwargs):
print(args)
print(b)
print(kwargs)
func(1,2,3,4,5,b=3,a=1,c=3)
*的用法
在定义处：
在定义处使用的一个* ,用来收集打包成元组
在定义处使用的两个**,用来收集打包成字典
在调用处：
在调用处使用的一个*,用来解包容器类型数据(常用:列表或元组)
在调用处使用的一个**,用来解包字典
1.调用处的一个星星*
把列表里面的1和2两个元素,单独拿出来,作为参数进行赋值
好处: 可以控制参数在调用处的总长度
def func(a,b,g,j,f,z,*,c,d):
# print(1)
print(a,b,g,j,f,z)
print(c,d)
lst = {
4,5,6,7,8,9}
func(*lst,c=3,d=4)
结果为：
4 5 6 7 8 9
3 4
2.调用处的俩个星星：
def func(a,b,*,c,d):
# print(1)
print(a,b)
print(c,d)
# 等价 <==> func(1,2,c=3,d=4)
dic = {
"c":3,"d":4}
func(1,2,**dic)
打印结果为：
1 2
3 4
3.综合一起（*和**的用法在调用处一样可以使用,负责解包,参数赋值）
lst = [1,2]
dic = {
"c":3,"d":4}
func(*lst,**dic)
打印结果为：
1 2
3 4
总结：
当所有的参数放在一起时,如何定义?
按照如下顺序定义:
普通形参 -> 默认形参 -> 普通收集参数 -> 命名关键字参数 -> 关键字收集参数
想收集所有的参数:
def func(*args,**kwargs):
pass
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
# f1(1, 2) # a=1,b=2,c=0,args=(),kw={}
# f1(1, 2, c=3) #a=1,b=2,c=3,args=(),kw={}
# f1(1, 2, 3, 'a', 'b') #a=1,b=2,c=3,args=("a","b") kw={}
# f1(1, 2, 3, 'a', 'b', x=99) #a=1,b=2,c=3,args=("a","b") kw={x:99}
f2(1, 2, d=99, ext=None) #a=1,b=2,c=0,d=99,kw={ext:None}
函数的返回值return
概念：
讲函数内部的变量,弹到函数外 把结果返回到函数的调用处
(1) return + 六大标准数据类型,还可以是函数(类对象)
(2) 执行return,意味着函数终止了,后面的代码不执行
(3) 函数中没有定义return 返回值,默认返回None关键字
（1）return + 六大标准数据类型,还可以是函数(类对象)
# 函数的定义处
def func():
# return 1
# return 3.4
# return [1,2,3]
return {
'a':1,"b":2}
# 函数的调用处
res = func()
print(res) # {'a': 1, 'b': 2}
（2）.执行return,意味着函数终止了,后面的代码不执行
def func():
print(1)
print(2)
return 3
print(4)
print(5)
res = func()
print(res) # 1 2 3
def func():
for i in range(10):
if i == 5:
return "结束了"
print(i)
res = func()
print(res)
结果为：
0
1
2
3
4
结束了
(3) 函数中没有定义return 返回值,默认返回None关键字
def func():
a = 1
res = func()
print(res) # None
# print 内置函数内部没有自定义返回值,所以返回None
res = print(123)
print(res) # None
应用实例：使用return 写一个计算器
def calc(sign,num1,num2):
if sign == "+":
res = num1 + num2
elif sign == "-":
res = num1 - num2
elif sign == "*":
res = num1 * num2
elif sign == "/":
if num2 == 0:
return "小伙砸,除数不能为0哦"
res = num1 / num2
else:
return "兄弟,你这个符号,我不会算"
return res
res = calc("$",10,0)
print(res) # 兄弟,你这个符号,我不会算
函数的使用
1.可以把函数当成变量一样使用
（1）函数名是个特殊的变量，可以当做变量赋值
def func():
return "我是一个函数"
a = 10
print(a) # 10
a = func
res = a()
print(res) # 我是一个函数
（2）函数名可以作为容器类型数据的元素
def func1():
print("我是函数1")
def func2():
print("我是函数2")
def func3():
print("我是函数3")
def func4():
print("我是函数4")
lst = [func1,func2,func3,func4]
for i in lst:
# print(i)
i()
结果为：
我是函数1
我是函数2
我是函数3
我是函数4
（3）函数名可以作为函数的参数
# func是函数
def func():
print("我是func哦")
# func是形参
def func5(func):
# 是函数就可以调用
func() #我是func哦
# 当调用func5时 , 把实参func函数 赋值给 形参func变量
func5(func)
（4）函数名可作为函数的返回值
def func6(c_func):
return c_func
res = func6(func)
res() # 我是func哦
2.全局变量和局部变量
局部变量: 在函数内部定义的变量,作用的范围在函数内部(作用域)
全局变量: 在函数外部定义的变量或者在函数内部通过global关键字定义的,作用的范围横跨整个文件(作用域)
（1）局部变量的获取和修改
def func():
# 定义一个局部变量
a = 5
# 获取局部变量
print(a)
# 修改局部变量
a = 10
func() # 5
# 局部变量无法直接在函数外使用
# print(a)
（2）全局变量的获取和修改
# 定义一个全局变量
b = 15
# 获取全局变量
print(b)
# 修改全局变量
b = 20
# 全局变量的作用范围横跨整个文件
def func2():
print(b)
func2() # 20
(3)全局变量可以通过global 关键字在函数内部进行定义
def func2():
global c
c = 100
func2()
print(c)
(4)全局变量可以通过global 关键字在函数内部进行修改
d= 200
def func3():
global d
d = 301
func3()
print(d)
global的作用:
如果函数外部有当前这个全局变量,通过global可以在函数内部进行修改
如果函数外部没有当前这个全局变量,通过global可以在函数内部进行定义
生命周期和作用域
1.生命周期
内置变量(解释器退出) > 全局变量(文件运行结束时) > 局部变量(函数调用结束时,生命就终止了)
2.作用域
# 命名空间 : 划分一块区域保存所有数据,以字典的方式存储(变量与值形成映射关系).一共三种.
(1)内建命名空间:解释器启动时创建,直到解释器运行结束,生存周期最长
(2)全局命名空间:文件运行时创建,直到解释器运行结束,生存周期较长
(3)局部命名空间:函数调用时,里面的局部变量才创建,调用结束后即释放,生存周期较短
#命名空间的提出是为了划分和控制变量是否可见,以及生存周期的长短.
#命名空间 创建顺序:(了解)
python解释器启动->创建内建命名空间->创建全局命名空间->创建局部命名空间
#命名空间 销毁顺序:(了解)
函数调用结束后->销毁函数对应的局部命名空间数据->销毁全局命名空间数据->销毁内建命名空间数据
THE END
