python有关函数

(124) 2024-04-13 08:01:02

数据类型

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)
  1. 强制转换成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))
    
  2. 强制转换成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
    
  3. 强制转换成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
    
  4. 强制转换成bool 类型
    bool数据类型只有Ture和False俩种
    因此转换成布尔类型为假的有十种情况
    0 0.0  False 0j '' [] ( )  set()  { 
         } None
    #None一般用来初始化变量的,表达一个空的,什么也没有,是系统的关键字
    res=bool(None)
    print(res)
    
  5. 自动类型转换

    转换方式:自动转换时,默认把低精度向高精度转换

    精度级别: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+4j
    
    2.容器类型的强制转换
    1. 强制转换成str
      var1 = "我真的是个帅哥哥"
      var2 = [1,2,3]
      var3 = (4,5,6)
      var4 = { 
             "a","b","c"}
      var5 = { 
             "花和尚":"鲁智深","智多星":"吴用","母夜叉":"杜十娘"}
      var6 = 789
      #特点为:单纯的在当前数据类型的两边,套上引号
      
    2. 强制转换成列表list
      res = list(var1)
      res = list(var3)
      res = list(var4)
      res = list(var5)
      print(res , type(res))
      ''' 如果是字符串,把字符串里面的元素一个一个拿出来,作为列表的新元素 如果是字典,只保留字典的键,舍弃值,形成新的列表 其他的数据类型,就是单纯的在当前数据类型的两边套上[] '''
      #注意:如果为number,就不能转换为列表
      
    3. 强制转换成tuple
      res = tuple(var1)
      res = tuple(var2)
      res = tuple(var5)
      print(res)
      """ 如果是字符串,把字符串里面的元素一个一个拿出来,作为元组的新元素 如果是字典,只保留字典的键,舍弃值,形成新的元组 其他的数据类型,就是单纯的在当前数据类型的两边套上() """
      
    4. 强制转换成set
      res = set(var1)
      res = set(var2)
      res = set(var5)
      print(res)
      """ 如果是字符串,把字符串里面的元素一个一个拿出来,作为集合的新元素 如果是字典,只保留字典的键,舍弃值,形成新的集合 其他的数据类型,就是单纯的在当前数据类型的两边套上{} """
      
    5. 强制转换成字典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 <= 100False 循环终止  
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+=13)打印十行十列隔行换色的小星星
i = 0
while i < 10:
	# 写上自定义的逻辑
	j = 0
	while j<10:
		if i % 2 == 0:
			print("★",end="")
		else:
			print("☆",end="")
		j+=1		
	# 打印换行
	print()
	i+=1499乘法表
方法一:
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
1pass 过(占位符)
if 5 == 5pass2break 终止当前循环(一定在循环中)	
# 错误的写法:
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.调用处的一个星星*
把列表里面的12两个元素,单独拿出来,作为参数进行赋值
好处: 可以控制参数在调用处的总长度
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关键字 
1return + 六大标准数据类型,还可以是函数(类对象)
# 函数的定义处
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
我是函数43)函数名可以作为函数的参数
# 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

发表回复