pyhton学习

python的基础生成，包括：迭代器和生成器、闭包与装饰器、函数参数与作用域、流程控制语句、散列类型与运算符、格式化输出与深浅复制、序列类型和转义字符、变量和数值类型。

pyhton基础学习

• 迭代器和生成器
  • 迭代器
    • 定义：操作可迭代对象，并操作时基于之前数据的更新工具
    • 作用：可以存储多个元素数据，进行更方便的数据读取操作
    • 语法
      • 可迭代哦对象.__iter__ iter(可迭代对象) next(可迭代对象)
    • 优点：减少代码量，更好管控有个多个元素的值
    • 缺点：无法获取长度，一次性用品无法返回
  • 生成器
    • a = [] def fun(): for i in range(10): a.append(i) return a print(fun())
    • 定义：自定义的迭代器
    • 带有yield的函数不再是一个普通函数，而是一个生成器genrator
      • 可用next()调用生成器对象来取值。next两种方式 t.__next__() ｜ next(t)
      • 可用for循环获取返回值（没执行一次，取生成器里面一个值）
      • tips：基本上不会用next()来获取下个返回值，而是直接使用for循环来迭代
• 闭包与装饰器
  • 闭包函数
    • 定义：在函数内在嵌套一个函数，但外部函数返回的不是一个具体的值，而是一个函数。
    • 优点：减少多次调用时不必要的开销，提供运行效率
    • 用法：
      • 例：def 函数名1 （行参1）： def 函数名2 （行参2）： return 返回值 return 返回值 变量名 = 函数名1(实参1) 变量名(实参2)
  • 装饰器
    • 定义：装饰器的本质上就是一个函数，它可以在让其他函数不需要做任何代码和调用模式的前提下，给函数增加额外的功能，装饰器的返回值也是一个函数对象。
    • 特点
      • 本质是一个函数
      • 参数就是你要装饰的函数名
      • 返回值是装饰完的函数值
      • 不需要被装饰函数做任何改动
    • 用法
      • def 函数名1（行参）： 行参（） return 返回值 @函数名1 被装饰函数...
    • 示例
      • 带参示例
        • import time def time1(fun): def timer(num): strat_time = time.time() fun(num) stop_time =time.time() print(strat_time-stop_time) return timer @time1 def test1(num): time.sleep(2) print(num) test1(123)
      • 不带参示例
        • import time def time1(fun): def timer(): strat_time = time.time() fun() stop_time =time.time() print(strat_time-stop_time) return timer @time1 def test1(): time.sleep(2) print('aaa') test1()
• 函数参数与作用域
  • 函数
    • 定义：把一段代码封装起来，成为具有一段特点的功能、可重用
      • tips：（函数 = 方法 ，实现一个特定的操作）
    • 用法
      • 用法1： def 定义名(): 代码 代码 代码
        • def Introduce(): #定义代码名 print('姓名') print('名字') print(Introduce())#直接输出 Int = Introduce() #代码赋值给变量 print(Int)#输出
      • 用法2： def 定义名(): pass #内容不能为空，pass占位
        • def Pass(): pass #忽略
      • 用法3： def 定义名(): 代码 return"" #返回值
        • def num(): sum = 1+1 sum2 = 1 + 11 return sum #调用 print(num())#输出
    • 优点
      • 提高项目的结构性，分工明确，提高代码可读性
      • 遇到重复功能时，直接调用
      • 遇到拓展功能时，直接修改
    • 定义函数名称的方式
      • 首字符不能是数字和特殊符号
      • 区分大小写
      • 不能有关键名
      • 简明之意
    • 返回值：把这个值返回给函数本身
      • def num(num): return num+1 num(2)
  • 函数参数
    • 用法
      • def 定义名(参数1，参数2)： 参数使用 print(定义名(参数1，参数2))#使用
    • 类型
      • 行参：定义参数的时候，参数用的一个变量的名字
      • 实参：在调用函数时传递的变量名
  • 行参进阶
    • 必备参数：
      • 必备参数： def 定义名(参数1，参数2): #定义 定义名(参数1，参数2)#调用
    • 默认参数：
      • 默认参数： def 定义名(参数1，参数2 = 赋值)#定义 定义名(参数1)#调用 *参数2为默认参数
    • 不定长参数：
      • 不定长参数： def 定义名(*args): 定义名(参数1,参数2,.....) *args 形成元组
    • tips：
      • 字符串文档的用法
        • def num(num): ''' hello world ''' return num+1 num(2) print(num.__doc__)
  • 名称空间
    • 内建名称空间
      • 定义：存储内置函数的地方
      • 作用：
        • 随着pyhthon的启动查看，在关闭时清理、回收
        • 最先加载的名称空间
        • 例：print()、str()、float()等
    • 全局名称空间
      • 定义：自定的函数 #tips：不能是内置函数内的名字：
      • 作用：
        • 随着所在文件的执行而启动，在关闭时清理、回收
        • 第二个被加载的文件的名称空间
        • 例：自己定义的变量、自己定义的可调用函数
    • 局部名称空间
      • 定义：随着调用函数、结束时临时产生、回收的，函数行参 #tips：就是定义函数内的变量或函数
      • 生命周期：在调用函数时存活，结束时销毁
    • 堆栈：
      • 堆：存储数据的地方
      • 栈：存储数据名字的地方
    • 名称空间的加载顺序：内建名称空间>全局名称空间>局部名称空间
    • 名称空间的销毁顺序：局部名称空间>全局名称空间>内建名称空间
    • 名称查找的优先级：局部名称空间--全局名称空间--内置名称空间
  • 作用域
    • 全局作用域：整个程序都可以使用
    • 局部作用域：局部成语可以使用
    • 定义域：只用在域内可以使用 #tips：如定义函数内，定义的变量和函数
  • 匿名函数（lambda 表达式）：
    • 用法：函数题仅有1行表达式，就可以使用lambda表达式代替
      • 定义名 = lambda 变量值：表达式
        • add = lambda x,y:x+y print(add(3,4))
    • 优点：
      • 对于单行函数，使用 lambda 表达式可以省去定义函数的过程，让代码更加简洁
      • 对于不需要多次复用的函数，使用 lambda 表达式可以在用完之后立即释放，提高程序执行的性能
• 流程控制语句
  • 定义作用
    • 顺序执行：由上往下顺序执行，为线性结构
    • 选择执行：根据条件的成立与否，执行对应语句
    • 循环执行：如果条件不满足，一直重复对应语句，指导满足为止
    • tips：python使用缩进来控制代码块(4个空格)
  • if(选择执行语句):
    • 功能：判断对应条件的真假，执行相关语句
    • 用法：
      • if 判断条件 : 执行语句 elif 判断条件 : 执行语句 else: #否则 执行语句 *ps*：elif ：else if的简写
        • #双分支 name = '马梓轩' #定义用用户名 password = 1234 #定义密码 inme = input('用户名：') #输入用户名 ipw = int(input('密码：')) #输入密码 if inme == name and password == ipw: #判断用户名密码输入的正确 print('登陆成功') #输出语句 else: #否则 print('用户名密码错误') #输出语句 #多分支 chinese = int(input('输入你的语文成绩')) if chinese >= 60: if chinese>= 60 and chinese <80: print('良好') elif chinese>= 80 and chinese <90: print('优秀') elif chinese>= 90 and chinese <=100: print('superman') else: print('不及格,在加油吧')
    • 其他
      • 单分支：单为if判断
      • 双分支：为if + else 进行条件判断，对真假结果进行判断，执行
    • 相关语句
      • 多分支：为if + elif +else 进行判断，对多个条件的结果为真和假结果进行判断，执行相关语句
  • while (循环执行语句)：
    • 定义：判断循环条件是否满足，满足跳出循环，不满足就继续循环
    • 用法：
      • while 循环条件 ： 执行语句 pass #跳过循环
        • num = 0 #定义次数 while num < 10: #循环条件 print('Hello world') #输出语句 num+=1 #定义次数+1
  • for (迭代循环)
    • 用法：遍历、迭代
    • 用法：
      • for 变量 in 可迭代对象 ：
• 散列类型与运算符
  • 散列类型
    • 定义：内部元素是无序的类型，不能通过下标读取，数据是不重复的
    • 集合(set)
      • 定义：负责存储不重复的数据，用于逻辑判断和数据去重（交集、并集、差集、子集、负集）
      • 表现形式：变量名 = {数据1，数据2,.....} #类型为<class 'set'>
      • 特点：1、输出会去重，自动排序，无法通过下标查询 2、重复的数据不会进入集合的内存空间
      • tips：列表名 = list(set(列表名)) #去重
      • 集合的判断
        • set1 = {1,2,3} set2 = {3,4,5} print(set1 & set2) #查询交集 print(set1 | set2) #查询并集 print(set1 - set2) #查询并集
        • 集合1 & 集合2 #判断交集，两个集合内的相同的数据
        • 集合1 ｜ 集合2 #判断并集，个集合所有数据整合，去重
        • 集合1 - 集合2 #判断差集合1减去与集合2的重复的数据，并输出
      • 使用方法
        • set1 = {1,2,3,1,3,4} set1.add(5)#增加数据5 print(set1) #set1.pop() set1.remove(5)#指定数据删除 print(set1) lis = [11,22,33,34] set1.update(lis)#添加序列类型 print(set1)
        • 增
          • 用法：集合名.add()
          • tips：列表不能直接放在集合中！
        • 删
          • 用法：集合名.pop()
          • tips:根据python的版本不同，函数功能不同
        • 改
          • 用法：集合名.remove() #添加序列类型
  • 运算符
    • 算数运算符
      • print(1+1) print(1-1) print(1*2) print(1/2) print(11//5)#整除运算 print(10%2)#取余运算 print(3**2)#次方运算
      • +加 -减 *乘 /除 //整除 %去余 **次方
    • 赋值运算符
      • a1=20 a1+=30# a1=a1+30 print(a1) a1-=10# a1=a1-10 print(a1) a1*=2# a1=a1*2 print(a1) a1//=2# a1=a1//2 print(a1) a1%=2# a1=a1%2 print(a1)
      • += -= *= //= %=
    • 比较运算符
      • a,b=10,20 print('a>b吗',bool(a>b)) print('a>b吗',a>b,type(a>b)) print('a<b吗',a<b) print('a<=b吗',a<=b) print('a>=b吗',a>=b) print('a==b吗',a==b)
      • == 等等于 != 不等 <>不等号 >大于 <小于 >=大于等于 <=小于等于
    • 逻辑运算符
      • a,b=1,2 print('--------------------and 并且') print(a==1 and b==2) print(a==1 and b<2) print(a!=1 and b==2) print(a!=1 and b!=2) print('--------------------or 或者') print(a==1 or b==2) print(a==1 or b<2) print(a<1 or b==2) print(a!=1 or b!=2) print('--------------------not 非"反义') T=True F=False print(not T) print(not F) print('--------------------in/not in 非"在什么里') name='马梓轩' print('马' in name) print('a' in name) print('马' not in name) print('a' not in name)
      • and 并且 or 或者 not 反义 in 在什么里面
• 格式化输出与深浅复制
  • 格式化输出
    • 相加输出：字符串+字符串方式输入，如果其中一个类型不为字符串则会报错
      • name = "马梓轩" age = 24 print("我是"+name+'今年',age)
    • f-string输出：f"xxx{变量名}xxx{变量名}" #可以对变量进行数据操作
      • name = "马梓轩" age = 24 print(f"我是{name}今年{age}") print(f"我是{name[0]}今年{age}")
    • format输出:'xxx{}xxx{}'.format(变量名，变量名) #可以下标输出,数值类型和序列类型都可
      • name = "马梓轩" age = 24 print("我是{}今年{}"fromat(name,age)) print("我是{1}今年{0}"fromat(age,name))
    • 占位符：
      • 参数：%类型'%(变量)，%s：字符型，%d: 整形，%f：浮点型 *%.2f(保留2位小数)，%c：输出ASEii码
      • 使用方式：“xxx%d，xxx%s"%(变量，变量)
        • name = "马梓轩" age = 24 print("我是%s今年%d"%(name.age))
    • join（分隔符）："～".join
      • print('~'.join(['wo','ni'])) # ~分割
  • 深浅复制
    • 多维列表：变量名= [[数据1，数据2],[[数据1，数据2]]]
    • 深浅复制1-列表copy（列表的复制）：
      • 变量名1 = [] 变量名2 = coyp.copy(变量名1)
        • li1 = [1,2,3] #建立列表li1 li2 = copy.copy(li1) #建立拷贝列表li1为li2，并新建 li1[0] = 'wo' #修改值 print(li2) print(id(li1),id(li2))#并不相同
    • 深浅复制2-多维列表copy：
      • 变量名1= [[数据1，数据2],[[数据1，数据2]]] 变量名2 = coyp.copy(变量名1) 变量名2[0][0]=数据3 结果：主表ID不同，从表ID相同（会同时改变）
        • lst2 = copy.copy(lst1) lst1[0][0] = 'wo' print(id(lst1),id(lst2)) #主表不同 print(id(lst1[0]),id(lst2[0])) #从表相同
      • 说明： 主表 赋值主表为新表时：ID相同 COPY主表为新表时：ID不同 从表 赋值主表为新表时：ID相同 COPY主表为新表时：ID相同 浅复制 只复制外层列表，并不给内层列表新建内存空间 深复制 复制外层和内层，并都新建内存空间
    • 深浅复制3-copy.deepcopy
      • 变量名1= [[数据1，数据2],[[数据1，数据2]]] 变量名2 = coyp.deepcopy(变量名1) 变量名2[0][0]=数据3
        • lst2 = copy.deepcopy(lst1) #使用copy.deepcopy()进行拷贝 lst1[0][0] = 'wo' #修改从表 print(id(lst1),id(lst2)) #查询主表ID print(id(lst1[0]),id(lst2[0])) #查询从表ID print(lst1) print(lst2)
      • 使用copy.deepcopy函数，使其从表id不同
• 序列类型和转义字符
  • 序列类型
    • 定义： 普通的是数值类型，只能存储一个数据如果要存储多个数据，就需要使用序列类型。
    • 序列类型的特性：
      • 下标：简单理解为序列里每个数据的坐标
        • lst = list(['hello world',1,12.13,True]) #定义一个列表 print(id(lst))#列表ID print(type(lst[1]))#查询列表里下表为1的数据的类型 print(type(lst)) 4460578304 <class 'int'> <class 'list'>
        • *从左到右，第一个数值坐标为0，第二个数据数值坐标为1 ，......
      • 索引：通过下标的值找到对应的数值
      • 切片：在序列中提取几个数据，正向左到右，逆向右到左（负 到 0）
        • num = '123456789' #定义字符串 num[1:3] '23'
      • 步长 ：定义提取数据之间，跨越几位下标
        • num = '123456789' #定义字符串 num[::2] # 默认为0:默认无限（到无数据为止）:步长为2（提取从起始位置到终止位置每跨两个下标的数据） '13579'
    • Str（字符串）：
      • 定义：用于存储字符（汉字，英文，特殊符号）
      • 声明方式：变量名 = “字符串” #类型为<class 'str'>
      • tips：*引号之间不能混用，但是可以相互嵌套，‘’‘用于存储数据‘’‘
      • 使用方法：
        • a = ' a ds dsds Fsdds ' print(a) print(a.replace('d','b')) #将字符串a中 的d值转换为b print(a.replace(' ','')) #将字符串a中 的空格值删除 print(a.replace('s','我',2))#将字符串a中 的s值更改为我，两次 print(a.upper()) #将a字符串中字母变成大写 print(a.lower()) #将a字符串中字母变成大写 print(a.split()) #将a字符串去掉空格 print(a.lstrip())#将a字符串去掉左空格 print(a.rstrip()) #将a字符串去掉右空格 a = 'name' print(a.title())#将a字符串单词首字母大写 print(a.split('m'))#将a字符串从m值开始分割成列表 print(a.find('m'))#查询a字符串中m的下标 print(a.isdigit())#判断是否为数字 print(a.isalpha())#断是否为字符串 print(a.isupper())#判断是否为大写 print(a.islower())#判断是否为小写 print(a.startswith('n'))#判断是否存在 print(a.endswith(a))#判断是否存在 a ds dsds Fsdds a bs bsbs Fsbbs adsdsdsFsdds a d我 d我ds Fsdds A DS DSDS FSDDS a ds dsds fsdds ['a', 'ds', 'dsds', 'Fsdds'] a ds dsds Fsdds a ds dsds Fsdds Name ['na', 'e'] 2 False True False True True True
        • 删
          • 字符串名.replace(要取代的名,替代的值)
          • 字符串名.replace(空格,空)#清除空格
          • 字符串名.replace(清除的值,空) #去掉这个字符串里面这个字符串名的所有值
          • 字符串名.replace(替换的值,取代的值，替换的次数)
        • 改
          • 字符串名.upper()#把字符串的字母大写
          • 字符串名.lower()#把所有字母小写
          • 字符串名.capitalize()#把首字母大写
          • 字符串名.strip()#去掉左右的空格
          • 字符串名.lstrip()#去掉左的空格
          • 字符串名.rstrip()#去掉右的空格
          • 字符串名.title()#把单词的首字母大写
          • 字符串名.split()#以字符串进行切隔，切割后变为列表
        • 查
          • 字符串名.find(检索的值,起点下标)#检索内容，得到下标 *若果没有搜索到的话，返回-1
          • 字符串名.isdigit()#判断是否为数字，返回bool值
          • 字符串名.isalpha()#判断是否为字符串，返回bool值
          • 字符串名.isupper()#判断是都为大写
          • 字符串名.islower()#判断是都为小写
          • 字符串名.startswith(制定名)#判断尾字符串与指定字符串是否相等
          • 字符串名.endswith()#判断名是否存在
        • tips：
          • ~数据类型的互相转换：变量名 = 数据类型(原变量)
          • ~序列类型的互相转换：变量名 = 序列类型(原变量)
    • list（列表）：
      • 定义：数据的集合，可以存放不同的单一类型数据。类型为list
      • ps：对数据的操作可以定义为增删改查（最底层的数据）
      • 定义方式： 命名 = [值1，值2，...]
        • lst = list(['hello world',1,12.13,True]) #定义一个列表
      • 列表相关操作：
        • 增
          • 定义:在列表里增加元素
          • 方式：
            • 列表名.append(元素) #在列表最后添加元素
              • lis = ['a',123.12,False,1] #定义个列表 lst = [12,23,45,22,'a','a','a'] print(lis) lis.append(70) #在最后添加元素 print(lis) ['a', 123.12, False, 1] ['a', 123.12, False, 1, 70]
            • 列表名.insert(下标,元素) #在指定位置添加元素
              • lis = ['a',123.12,False,1] #定义个列表 lst = [12,23,45,22,'a','a','a'] print(lis) lis.insert(1,'wo') #在制定位置添加元素 print(lis) ['a', 123.12, False, 1] ['a', 'wo', 123.12, False, 1]
            • 列表名.extend(列表) #在把列表里的数据添加到lis列表最后，实际为追加另一个表中的多个值
              • lis = ['a',123.12,False,1] #定义个列表 lst = [12,23,45,22,'a','a','a'] print(lis) lis.extend(lst) #追加另一个表中的多个值 print(lis) ['a', 123.12, False, 1] ['a', 123.12, False, 1, 12, 23, 45, 22, 'a', 'a', 'a']
        • 删
          • 定义：在列表中删除元素
          • 方式
            • 列表名.pop(下标值) #通过下标删除一个元素，默认删除最后
              • lis = ['a',123.12,False,1] #定义个列表 print(lis) lis.pop(2)#删除下标2的元素 print(lis) ['a', 123.12, False, 1] ['a', 123.12, 1]
            • 列表名.remove(元素名称) #通过元素名称删除一个元素，多个相同的元素名称删除最小下标的元素
              • lis = ['a',123.12,False,1] #定义个列表 print(lis) lis.remove(123.12)#删除名称为123.12的元素 print(lis) ['a', 123.12, False, 1] ['a', False, 1]
            • 列表名.clear() #清空列表里所有的数据
              • lis = ['a',123.12,False,1] #定义个列表 print(lis) lis.clear() #清除列表里所有的数据 print(lis) ['a', 123.12, False, 1] []
            • del 列表名 #删除列表 *也可以删除赋值或者制定数据
              • lis = ['a',123.12,False,1] #定义个列表 print(lis) del lis#清除列表里所有的数据 print(lis) ['a', 123.12, False, 1] --------------------------------------------------------------------------- NameError Traceback (most recent call last) /var/folders/bc/59cpm_3j7h5_jt9jjnh9qpp40000gn/T/ipykernel_1189/3210244144.py in <module> 2 print(lis) 3 del lis#清除列表里所有的数据 ----> 4 print(lis) NameError: name 'lis' is not defined
        • 改
          • 定义：在列表里通过下标修改元素
          • 方式：
            • 列表名[下标] = 元素 #通过下标修改列表中一个元素(可以通过切片)
              • lis = ['a',123.12,False,1] #定义个列表 print(lis) lis[0] = 'b' #修改0下标的值为‘b’ print(list(lis)) lis[0:2] = 'b','b','b'#修改0-2下标的值为‘b’ print(list(lis),id(lis)) ['a', 123.12, False, 1] ['b', 123.12, False, 1] ['b', 'b', 'b', False, 1] 4355290432
        • 查
          • 定义：在列表里通过下标查找元素
          • 方式
            • 列表名.index（元素名称） #检索表格里的元素
              • lis = ['a',123.12,False,1] #定义个列表 print(lis) print(lis.index('a'))#检索‘a’的下标 print(lis) ['a', 123.12, False, 1] 0 ['a', 123.12, False, 1] 1
            • 列表名.index（元素名称,下标） #检索表格里的元素,下标之后的！
              • lis = ['a',1,123.12,False,1] #定义个列表 print(lis) print(lis.index(1,2))#检索‘a’的下标 print(lis) print(lis.count('a'))#搜索元素名为‘a’的数量 ['a', 1, 123.12, False, 1] 4
            • 列表名.count（元素名称） #查询元素的数据量
              • lis = ['a',1,123.12,False,1] #定义个列表 print(lis) print(lis.count('a'))#搜索元素名为‘a’的数量 ['a', 1, 123.12, False, 1] 1
        • 其他
          • 拷贝列表：
            • 新列表名 = 旧列表名.copy() #拷贝整个列表
          • 列表排序：
            • 列表名.sort() #将列表排序
          • 倒序输出：
            • 列表名.sort(reverse=True) #将列表倒序
            • 列表名.reverse() #将列表反向输出
    • tuple（元组）：
      • 定义：用小括号包裹的数据，其中数据不准许修改。类型为tuple
      • 定义方式： 命名 =（值1，值2，...）
      • ps：当元组只有一个元素时也要加逗号，不然会默认单独数据的类型
        • num = (1) print(type(num)) num = (1,) print(type(num)) <class 'int'> <class 'tuple'>
      • 元组相关操作：
        • 查：
          • 元组名.index（元素名称） #检索元组里的元素
            • tup = (1,2,12.23,'wo') #定义个元素 print(tup.index('wo')) #检索‘wo’的下标 3
          • 元组名.count（元素名称） #查询元素的数据量
            • tup = (1,2,12.23,'wo') #定义个元素 print(tup.count('wo')) #搜索元素名为‘wo’的数量 1
    • dict(字典)：
      • 定义： 具有对应关系的数据类型，通过键值对的方式来存储数据。类型为<class 'dict'>
      • 定义方式： 字典名 = {key 1:value 1,key 2:value 2}
      • 字典特性： 1、通过键值相对的方式来取值，不是通过下标 2、字典是可以变的而且可以嵌套 3、键是为唯一且不可变，值可变可重复
      • 相关操作
        • 增
          • dc = {1:2} dc = dic.copy() #copy字典 print(dc) dc.setdefault('性别','男') #新增键值 print(dc) dc.setdefault('家乡') #新增键
          • 新字典名 = 复制字典名.copy()
          • 新字典名.setdefault(键) #值为None
          • 新字典名.setdefault(键名,值)
        • 删
          • dc = {1:2,'家乡':None} dc.pop('家乡') #删除键 print(dc) dc.popitem() #dc.clear()#清空字典
          • 字典名.pop(键) #删除字典中键和对应的值
          • 典名.popitem() #随机删除键值对
          • 典名.clear() #清空字典
        • 改
          • dc = {1:2,'家乡':None,'name':'马梓轩'} dc.update({'name':'马梓轩！'})#修改键值对
          • 字典名.update({键:值})#修改键值对，没有的话新添加
        • 查
          • dc = {1:2,'家乡':None,'name':'马梓轩'} print(dc) print(dc.get('name'))#查询‘name’对应的值 print(dc.keys(),type(dc.keys()))#查询键和类型 print(dc.values(),type(dc.values()))#查询值和类型 print(dc.items(),type(dc.items()))#查询键值对
          • 字典名.get(键)#查询键对应的值
          • 字典名.keys() #查询键<class 'dict_keys'>
          • 典名.values() #查询值<class 'dict_values'>
          • 典名.items() #查询键值对<class 'dict_items'>
  • 转义字符
    • 定义：具有特别含义的字符。
    • 功能字符：\n （换行）、 \t（制表符tab）、\\（正常输出反斜杠）、\“（输出引号）、\r（回车）、\t（系统提示音）
      • # \n 换行 'newline' print('hello\nword') # \r 回车 print('hello\tword') # \t 水平制表符 print('hello\tword') print('hellooooo\tword') # \b 推格一个格 print('hello\bword') print('http:\\\\www.baidu.com') print('我要说：\'123\'') #源字符，不希望字符串中的转义字符起作用，就使用源字符，就是在字符串之前加上r或者R print(r'http:\\www.baidu.com') #最后一个字符不能是反斜杠\ hello word hello word hello word hellooooo word hellword http:\\www.baidu.com 我要说：'123' http:\\www.baidu.com
    • ps：ord（数据转换为ASCII） chr（ASCII转换为数据 ）
      • ASCII(字符编码)：只有基本的英文，数字，特殊字符
      • UTF-8(万国码)：大部分国家语言文字整合
      • 字符串名.encode(编码格式) #输出二进制字符串
• 变量和数值类型
  • 变量
    • 定义：变量由：数据类型（type）、内存地址（id）、值（value）
    • 命名规则：
      • ～正常的变量：由数字、字母、下滑线组成 ～首字符：首字符不能为数字 ～不能用关键词作为变量名 ～大小写分明 ～命名的时候要有含义，并且尽量简单粗暴 ～一个变量全是大写的话，就表明它是常量，他的值不要去变
    • 常见命名法：
      • ~驼峰命名法（例：普通username，小驼峰userName，大驼峰UserName） ~匈牙利命名法（例：g_iUserAge g=全局变量，i=int类型 UserAge=变量名）
    • tips：
      • 变量并不是凭空生成，赋值后就会在计算机内存里开辟一个空间，来保存这个变量值，并绑定连接到变量名，就可以通过变量名来找到对应的值。
      • https://blog.csdn.net/qq_37851620/article/details/94731227 #参考地址
  • 数值类型
    • int（整型）
      • 定义：用于存储整型数据，没有小数
      • 声明方式：变量名 = 整数值 #类型为<class 'int'>
      • tips： 变量名 = int（数值）#数值为整型
    • float（浮点型）
      • 定义：用于存放小数数据
      • 声明方式：变量名 = 浮点数值 #类型为<class 'float'>
      • tips：变量名 = float（数值）#数值为浮点型
      • *python数值属于十进制，机器语言为二进制，使用decimal.Ddecimal函数转换
    • bool（布尔类型）
      • 定义：用作于判断，只有两个值（True 真/1 ， False 假/0）<class 'bool'>
      • tips：*可以用作于运算,注意首字母大写