Python 第十五天 串讲

Posted 2021-01-07 sophie99

Python: 弱类型的.解释型的高级编程语言

　　特点:简单.优雅.明确

　　变量:程序运行过程中产生的中间值,供给后面的程序使用.

　　变量的命名规范:

　　　　1.由数字.字母.下划线组成

　　　　2.不能以数字开头,更不能是存数字

　　　　3.不能用关键字

　　　　4.不要太长

　　　　5.不要用汉字

　　　　6.要有意义

　　　　7.区分大小写

　　　　8.推荐使用驼峰或下划线

　　变量的数据类型:

　　　　1.int:整数  + - * / // %   bit_length  得到二进制长度

　　　　2.str:字符串   +拼接  *重复 %格式化输出

　　　　　　索引和切片[start:end:step]  end取不到

　　　　　　upper() 大写  strip() 去掉左右两端的空格  spilt 切割 按什么切什么就没有了得到的是列表

　　　　　　replace(old,new) 替换  join() 把列表中的元素拼接成字符串

　　　　　　startswith() 以什么开头   find()/index() 查找  count() 计数  len()长度

　　　　　　编码:

　　　　　　　　encode()编码   decode() 解码

　　　　　　　　1.ASCII  1byte(位)  8bit(字符)

　　　　　　　　2.GBK   2byte(位) 16bit(字符)

　　　　　　　　3.UNICODE  4byte(位)  32bit(字符)

　　　　　　　　4.UTF-8  

　　　　　　　　　　英文:1byte(位)  8bit(字符)

　　　　　　　　　　欧洲; 2byte(位)  16bit(字符)

　　　　　　　　　　中文: 3byte(位)  24bit(字符)

　　　　　3.bool: 布尔值
　　　　　　　取值： True， False
　　　　　　　用来判断
　　　　　　　类型转换:
　　　　　　　　False: 0, ‘‘, None, [], {}, tuple(), set()
　　　　　　　　True: 除了上面的都是True

　　　　　4.list: 列表. 由[]表示.每个元素与元素之间用逗号隔开, 可以装任意类型的数据.
　　　　　　　列表是可变的. 并且列表由索引和切片功能
　　　　　　　1. 增
　　　　　　　　append() 追加
　　　　　　　　insert(索引, 数据)
　　　　　　　　extend(Iterable) 迭代添加
　　　　　　　2. 删除
　　　　　　　　pop()
　　　　　　　　remove(元素)
　　　　　　　　del 切片删
　　　　　　　　clear() 清空
　　　　　　　3. 修改
　　　　　　　　索引切片修改
　　　　　　　　lst[i] = "新元素"
　　　　　　　4. 查询
　　　　　　　　一般用索引
　　　　　　　　for循环

　　　　　　　5. 操作
　　　　　　　　count(). 计数
　　　　　　　　index() 查找元素
　　　　　　　　sort()排序
　　　　　　　　reverse() 翻转

　　　　　　　　列表不能直接在循环中删除. 因为涉及到元素移动.需要把要删除的内容添加到新列表中. 循环新列表. 删除老列表

　　　　　　拷贝:
　　　　　　　　1. = 赋值操作. 没有创建对象. 两个变量使用同一个对象.
　　　　　　　　2. 浅拷贝. 只拷贝一层. list.copy(), list[:]
　　　　　　　　3. 深拷贝. 和这个对象相关的内部信息全部拷贝一份. deepcopy() 原型模式

　　　　　　推导式: [结果 for循环 if判断]

　　　　5.dict 字典:
　　　　　　由{}表示. 内部存储key:value. key必须是可哈希的数据类型. 不可变. value:没有限制
　　　　　　字典没有索引和切片
　　　　　　1. 增
　　　　　　　　dic[新key] = value
　　　　　　　　dic.setdefault(key, value)
　　　　　　2. 删除
　　　　　　　　pop(key)
　　　　　　　　popitems() 随机删一个
　　　　　　　　del
　　　　　　　　clear() 清空
　　　　　　3. 修改
　　　　　　　　dic[老key] = 新value
　　　　　　　　dic.update({}) 把xxx字典更新到字典中

　　　　　　4. 查询:
　　　　　　　　通过key来查询
　　　　　　　　get(key, default)
　　　　　　　　setdefault(key, value)
　　　　　　5. 常用操作
　　　　　　　　keys() 获取所有的key
　　　　　　　　values()获取所有的value
　　　　　　　　items() 获取所有的键值对(key, value)

　　　　　　　　可以进行for循环
　　　　　　　　　　for key in dict:
　　　　　　　　　　　　print(key, dict[key])

　　　　　　　　　　for key in dict.keys():
　　　　　　　　　　　　print(key, dict[key])

　　　　　　　　　　for value in dict.values():
　　　　　　　　　　　　print(value)

　　　　　　　　　　for k, v in dict.items():
　　　　　　　　　　　　print(k,v)

　　　　　　　　len() 计算键值对的个数

　　　　　　　　字典在迭代的时候不可以改变大小把要删除的key保存在列表中. 循环列表. 删除字典

　　　　　　　　dict.fromkeys(key, value)
　　　　　　　　　　1. 返回给你新列表.
　　　　　　　　　　2. 所有的key公用同一个value

　　　　　　　　推导式: {key: value for循环 if}

　　　　6.tuple元组:
　　　　　　不可变.不可变指的是第一层基本上没有操作 count()  index()   len(): __len__()   可迭代    for 循环

　　　　7.set 集合
　　　　　　无序, 不重复, 可哈希(元素)
　　　　　　去重.
　　　　　　也可以循环.
　　　　　　fronzenset() 冻结的集合, 不可变, 可哈希

　　　　　　基本语法:
　　　　　　　　运算符:
　　　　　　　　　　1. 算数运算: +-*/ // % **
　　　　　　　　　　2. 比较运算:> < == >= <= != <>
　　　　　　　　　　3. 逻辑运算:
　　　　　　　　　　　　and 并且的含义. 左右两端必须同时为真. 结果才能是真
　　　　　　　　　　　　or 或者. 左右两端有一个是真. 结果就是真
　　　　　　　　　　　　not 非. 非真既假, 非假既真

　　　　　　　　　　　　顺序：() => not => and => or
　　　　　　　　　　　　a or b
　　　　　　　　　　　　如果a非零。 返回a。 否则返回b
　　　　　　　　　　　　and和or相反
　　　　　　　　　　　　a and b
　　　　　　　　　　　　如果a非零。 返回b。 否则返回0
　　　　　　　　　　4. 赋值运算
　　　　　　　　　　　　+= -= *= /= %=
　　　　　　　　　　　　a+=b a = a + b

　　　　　　　　　　5. 成员运算
　　　　　　　　　　　　xxx in xxxx
　　　　　　　　　　6. is和 ==
　　　　　　　　　　　　is： 比较的是内存地址
　　　　　　　　　　　　==: 比较的是值
　　　　　　　　　　　　小数据池(常量池): 会对str, int, bool进行缓存. 节省内存. 方便调用.

　　　　　　　　　　print(打印的内容, xxx, end="结束符", sep="分隔符")
　　　　　　　　　　str = input("提示") 用户交互

　　　　8.文件操作
　　　　　　open(文件路径, mode="模式", encoding="编码")
　　　　　　模式: r, w, a, r+, w+, a+, rb, wb, ab
　　　　　　for循环可以迭代文件句柄. 拿到的是一行一行的内容   for line in f
　　　　　　seek()移动光标
　　　　　　tell()查看光标位置

　　　　　　with open(xxxx) as f:
　　　　　　操作

　　　　　　　文件修改:
　　　　　　　　从源文件中读取内容. 修改, 然后写入到新文件中. 删除源文件. 重命名新文件

　　　　函数部分:
　　　　　　函数: 对功能或者动作的封装 类中的函数一般是方法
　　　　　　语法:
　　　　　　　　def 函数名(参数):
　　　　　　　　　　函数体(return)

　　　　　　　　ret = 函数名(实参)

　　　　　　函数名: 函数名就是一个变量名. 可以进行赋值. 可以作为参数, 可以作为返回值. 还可以作为集合类的元素
　　　　　　参数:
　　　　　　　　给函数传递的信息
　　　　　　　　1. 形参:
　　　　　　　　　　在函数声明的位置定义的变量.
　　　　　　　　分类:
　　　　　　　　　　1. 位置参数
　　　　　　　　　　2. 默认值参数, 共享
　　　　　　　　　　3. 动态传参
　　　　　　　　　　　　1. *args 动态接收位置参数
　　　　　　　　　　　　2. **kwargs 动态接收关键字参数
　　　　　　　　　　　　*,** 在形参位置表示聚合
　　　　　　　　　　　　*,** 在实参位置表示打散
　　　　　　　　　　顺序:
　　　　　　　　　　　　位置, *args, 默认值, **kwargs

　　　　　　　　　　def func(*args, **kwargs): 无敌传参
　　　　　　　　　　　　pass

　　　　　　　　2. 实参:
　　　　　　　　　　在函数调用的时候给函数传递的具体的值.
　　　　　　　　分类:
　　　　　　　　　　1. 位置参数
　　　　　　　　　　2. 关键字参数
　　　　　　　　　　3. 混合参数. 位置在前, 关键字在后
　　　　　　　　3. 传参:
　　　　　　　　　　把实参传递给形参的过程叫传参

　　　　　　　　名称空间:
　　　　　　　　　　1. 内置名称
　　　　　　　　　　2. 全局名称
　　　　　　　　　　3. 局部名称
　　　　　　　　作用域:
　　　　　　　　　　1. 全局作用域
　　　　　　　　　　2. 局部作用域
　　　　　　　　　　globals() 查看全局作用域中的内容
　　　　　　　　　　locals() 查看当前作用域中的内容

　　　　　　　　　　global 在局部引入全局变量, 创建全局变量
　　　　　　　　　　nonlocal 在局部, 引入离他最近的上一个变量

　　　　　　闭包: 内层函数访问外层函数中的变量. 最好是返回内层函数
　　　　　　　　作用:
　　　　　　　　　　1. 保护变量不被更改
　　　　　　　　　　2. 可以让一个变量常驻内存

　　　　　　　　def func():
　　　　　　　　　　a = 10
　　　　　　　　　　def inner():
　　　　　　　　　　　　return a
　　　　　　　　　　return inner
　　　　　　迭代器:
　　　　　　　　可迭代对象: 在数据类型中包含了__iter__.
　　　　　　　　迭代器: 访问__iter__可以获取到该数据类型的迭代器. 包含__iter__和__next__

　　　　　　　　特点:
　　　　　　　　　　1. 省内存
　　　　　　　　　　2. 惰性机制
　　　　　　　　　　3. 只能向前
　　　　　　　　模拟for循环
　　　　　　　　　　lst = []
　　　　　　　　　　it = lst.__iter__() # iter(lst)
　　　　　　　　　　while 1:
　　　　　　　　　　　　try:
　　　　　　　　　　　　　　it.__next__() # next(it)
　　　　　　　　　　　　except StopIteration:
　　　　　　　　　　　　　　break

　　　　　　生成器:
　　　　　　　　生成器的本质是迭代器
　　　　　　　　生成器有三种方式来创建:
　　　　　　　　　　1. 生成器函数
　　　　　　　　　　2. 生成器表达式
　　　　　　　　　　3. 类型转换(range())
　　　　　　　　生成器函数:
　　　　　　　　　　生成器函数中包含yield
　　　　　　　　　　yield表示返回. 可以分段的执行函数

　　　　　　　　　　生成器函数在被调用的时候. 获取生成器. 而不是执行函数
　　　　　　　　　　def func():
　　　　　　　　　　　　yield xxxx
　　　　　　　　　　func() # 获取生成器

　　　　　　　　生成器使用:
　　　　　　　　　　1. __next__() 执行到下一个yield
　　　　　　　　　　2. send() 可以给上一个yield传值

　　　　　　　　yield from:
　　　　　　　　　　把一个可迭代对象转换成生成器

　　　　　　　　生成器表达式:
　　　　　　　　　　(结果 for if)

　　　　　　内置函数: 68个.

　　　　　　　　lambda:
　　　　　　　　　　匿名函数
　　　　　　　　　　lambda 参数: 返回值