python基础
(1)python 简介
89年开发的语言,创始人范罗苏姆(Guido van Rossum),别称:龟叔(Guido).
python具有非常多并且强大的第三方库,使得程序开发起来得心应手.
Python程序员的信仰:人生苦短,我用python!
开发方向： 机器学习人工智能 ，自动化运维&测试 ，数据分析&爬虫 ，python全栈开发
(2)python 版本
python 2.x 版本，官方在 2020 年停止支持,原码不规范,重复较多
python 3.x 版本，功能更加强大且修复了很多bug,原码清晰,简单
(3)编译型与解释型语言区别:
编译型:一次性,把所有代码编译成机器能识别的二进制码,在运行
代表语言:c,c++
优点: 执行速度块
缺点: 开发速度慢,调试周期长
解释型:代码从上到下一行一行解释并运行
代表语言:python,php
优点: 开发效率快,调试周期短
缺点: 执行速度相对慢
*linux 操作系统默认支持python语言，可直接使用
(4)python的解释器:
(1)Cpython(官方推荐)
把python转化成c语言能识别的二进制码
(2)Jpython
把python转化成java语言能识别的二进制码
(3)其他语言解释器
把python转化成其他语言能识别的二进制码
(4)PyPy
将所有代码一次性编译成二进制码,加快执行效率(模仿编译型语言的一款python解释器)
注释
就是对代码的解释 方便大家阅读python代码
(1)注释的分类
(2)注释的注意点
(3)注释的排错性
(1)注释的分类 ： 1.单行注释 2.多行注释
# 1.单行注释 以#号开头 ，右边的所有东西都被当做说明文字 ，程序不进行编译运行。
print(‘hello world’)
# 2.多行注释 三个单引号 或 三个双引号
'''
这是第一行
这是第二行
'''
(2)注释的注意点
如果外面使用三个单引号，里面使用三个双引号，反之亦然。
(3)注释的排错性
先注释一部分代码，然后执行另外一部分，看看是否报错，逐层缩小报错范围，找到最终错误点。
变量
可以改变的量,实际具体指的是内存中的一块存储空间
(1)变量的概念
(2)变量的声明
(3)变量的命名
(4)变量的交换
* 常量就是不可改变的量,python当中没有明确定义常量的关键字,
所以约定俗成把变量名大写就是常量,表示不可改变
(1)变量的概念: 可以改变的量就是变量。具体指代的是内存的一块空间
(2)变量的声明:
#1. a = 1 , b = 2
#2. a,b = 1,2
#3. a = b = 3
(3)变量的命名:
#字母数字下划线 ，首字符不能为数字
#严格区分大小写 ，且不能使用关键字
#变量命名有意义 ，且不能使用中文哦
(4)变量的交换:
#a,b = b,a
python六大标准数据类型:
数据类型分类：
(1)Number 数字类型 (int float bool complex)
# type 获取变量的类型 # id 变量所指向的值的内存地址 # int intvar = 1 print(intvar,type(intvar),id(intvar)) intvar = 0b1010 print(intvar,type(intvar),id(intvar)) # float floatvar = 3.14e2 # 小数点向右移两位 print(floatvar,type(floatvar),id(floatvar)) # bool 布尔型（True 和 False） boolvar = True print(boolvar,type(boolvar),id(boolvar)) # complex 复数：实数 + 虚数 3+4J 如果有一个数的平方是-1，那么这个数就是j # 表达式一 complexvar = 3 + 2j print(complexvar,type(complexvar),id(complexvar)) # 表达式二 complexvar = complex(3,2) print(complexvar,type(complexvar),id(complexvar))
(2)str 字符串类型
# 字符串：用引号引起来的就是字符串 """ \ 转义字符，有意义的字符变得无意义，无意义的变得有意义 \n 换行 \r\n 换行 \r ==> 把\r后面的字符串直接拉到当前行的行首 \t ==> 缩进，制表符 """ # 单引号 strvar = 'Hello world' print(strvar,type(strvar)) # 双引号 strvar = "Hello world" print(strvar,type(strvar)) # 三引号 支持跨行操作 strvar = """ Hello world """ print(strvar,type(strvar)) # 元字符串 r + "字符串" 让转义字符失效 strvar = r"c:\file" print(strvar,type(strvar)) # 字符串的格式化 """ %d --> 整型占位符 %f --> 浮点型占位符 %s --> 字符串占位符 语法："字符串%s"%(值1，值2，...) """ strvar = "流畅的%s，价格%d"%('python',99) print(strvar,type(strvar))
(3)list 列表类型
# 容器类型数据 """ list 列表，可获取，可修改，有序 """ # 定义一个空列表 listvar = [] print(listvar,type(listvar)) # 获取列表元素 通过索引取数 # 正索引： 0 1 2 4 5 # 逆索引： -5 -4 -3 -2 -1 listvar = [11,22,33,44,55] print(listvar[-1]) # 拿到列表最后一个元素 """ len 获取容器类型数据的长度，元素个数 """ print(len(listvar)) # 修改列表元素 listvar[0] = 66 print(listvar)
(4)tuple 元组类型
""" tuple 元组 可获取，不可修改，有序 """ # 定义一个空元组 tuplevar = () print(tuplevar,type(tuplevar)) # 判断是否元组，在于逗号 tuplevar = (1) tuplevar = (1,) print(tuplevar,type(tuplevar)) tuplevar = (1,2,3,4,5) print(tuplevar[1]) # 获取元组中的值 """ 元组中的值不可修改 """
(5)set 集合类型
""" set 集合（集合是用来做交叉并补操作的） 自动去重，无序 不能获取值，不能修改值 """ # 定义一个空集合 使用大括号为空时默认为字典类型 setvar = {1,2,3,4,5} print(setvar,type(setvar)) setvar = set() print(setvar,type(setvar))
(6)dict 字典类型
""" dict 字典 python 3.6版本之前无序 python 3.6版本之后有序（本质上无序） 以健值对存储的数据 语法：{健1:值1,健2:值2} 字典和集合中的值有要求，需要可哈希数据 可哈希数据：（不可便数据）Number(int,float,bool,complex) 可哈希数据可以作为字典的健和集合的值 不可哈希数据：（可变数据）list dict set """ # 定义一个空字典 dictvar = {} print(dictvar,type(dictvar)) dictvar = {'a':1,'b':2} # 通过健获取字典中的值 print(dictvar['a']) # 修改字典中的值 dictvar['a'] = 3 print(dictvar)
Number数字类型分类：
int : 整数类型 ( 正整数 0 负整数 )
float: 浮点数类型 ( 1普通小数 2科学计数法表示的小数 例:a = 3e-5 #3e-05 )
bool: 布尔值类型 ( 真True 和 假False )
complex: 复数类型 ( 声明复数的2种方法 ) (复数用作于科学计算中,表示高精度的数据,科学家会使用)
容器类型分类：五个
str "nihao"
list [1,2,3]
tuple (6，7，8)
set {'a',1,2}
dict {'a':1,'b':2}
自动类型转换
当2个不同类型的数据进行运算的时候,默认向更高精度转换
数据类型精度从低到高: bool int float complex
""" 精度从低到高： bool --> int --> float --> complex """ # 布尔类型转换为整型 True = 1 False = 0 res = True + 1 print(res) # 2 # 布尔类型转换为浮点型 res = False + 3.14 print(res) # 布尔类型转换为复数 res = True + 3+4j print(res) # 整型转换为浮点型 res = 3 + 3.14 print(res) # 整型转换为复数 res = 3 + 3+4j print(res) # 浮点型转换为复数 res = 3.14 + 3+4j print(res)
强制类型转换
# -->Number部分
int : 整型 浮点型 布尔类型 纯数字字符串
float: 整型 浮点型 布尔类型 纯数字字符串
complex: 整型 浮点型 布尔类型 纯数字字符串 (复数)
bool: ( 容器类型数据 / Number类型数据 都可以 )
# Number部分的强制类型转换 var1 = 123 var2 = 3.14 var3 = True var4 = 3 + 4j var5 = '456' var6 = 'abc' # 1. 强制转换为int res = int(var2) # 3 res = int(var3) # 1 res = int(var4) # TypeError: can't convert complex to int res = int(var5) # 456 res = int(var6) # ValueError: invalid literal for int() with base 10: 'abc' print(res) # 2. 强制转换为float res = float(var1) # 123.0 res = float(var3) # 1.0 res = float(var4) # TypeError: can't convert complex to float res = float(var5) # 456.0 res = float(var6) # ValueError: could not convert string to float: 'abc' print(res) # 3. 强制转换为complex res = complex(var1) # (123+0j) res = complex(var2) # (3.14+0j) res = complex(var3) # (1+0j) res = complex(var4) # (3+4j) res = complex(var5) # (456+0j) res = complex(var6) # ValueError: complex() arg is a malformed string print(res) # 4. 强制转换为bool """ bool类型为假的10种情况： 0 、0.0 、False 、0j 、'' 、[] 、() 、set() 、{} 、None None代表空，一般用在变量初始化 """ res = bool(var1) # True res = bool(var2) # True res = bool(var3) # True res = bool(var4) # True res = bool(var5) # True res = bool(var6) # True print(res)
# -->容器类型部分
str: ( 容器类型数据 / Number类型数据 都可以 )
list: 字符串 列表 元组 集合 字典
tuple: 字符串 列表 元组 集合 字典
set: 字符串 列表 元组 集合 字典 (注意:相同的值,只会保留一份)
# 容器类型强制转换 var1 = "Hello World" var2 = ["a","b","c"] var3 = ("e","f","g") var4 = {"a","b","c"} var5 = {"a":1,"b":2} var6 = 123 # 1.转换为字符类型str """ 容器类型数据和Number类型数据可以 规律：基于原来的数据类型两边加上引号 """ res = str(var2) # ['a', 'b', 'c'] res = str(var3) # ('e', 'f', 'g') res = str(var4) # {'a', 'c', 'b'} res = str(var5) # {'a': 1, 'b': 2} <class 'str'> print(res,type(res)) print(repr(res)) # "{'a': 1, 'b': 2}" """ repr:以字符串的形式原型化输出数据 """ # 2. 转换为列表类型 list """ 规律： 1.如果是字符串，把里面的字符一个一个拿出来，作为列表的每一个元素 2.如果是其它容器数据，基于原数据，把两边的符号换成[],换成列表 3.如果是字典，获取字典的健组成列表 """ res = list(var1) # ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'] res = list(var3) # ['e', 'f', 'g'] res = list(var4) # ['b', 'a', 'c'] res = list(var5) # ['a', 'b'] print(res) # 3. 转换为元组类型 tuple """ 规律： 1.字符串，把里面的字符一个一个拿出来，作为元组的每个元素 2.容器数据，基于原数据，把两边的符号换成(),换成元组 3.字典，获取字典的健，组成元组 """ res = tuple(var1) # ('H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd') res = tuple(var2) # ('a', 'b', 'c') res = tuple(var4) # ('a', 'b', 'c') res = tuple(var5) # ('a', 'b') print(res) # 4. 转换为集合类型 set """ 规律： 1.字符串，把里面的字符拿出来，作为集合的元素 2.容器数据，基于原数据，把两边的符号换成{],换成集合 3.字典，获取字典的健，组成集合 集合的特征：自动去重，无序 """ res = set(var1) # {'l', 'r', 'e', 'd', ' ', 'H', 'o', 'W'} res = set(var2) # {'c', 'a', 'b'} res = set(var5) # {'b', 'a'} print(res)
dict: 使用 二级列表,二级元组,二级集合(里面的容器数据只能是元组)
# 二级容器，外层是一个容器类型数据，里面的元素还是一个容器类型数据 listvar = [1,2,3,(4,5,6)] # 二级列表 listvar = [1,2,[3,4]] # 二级元组 tuplevar = (1,2,3,(4,5,6)) # 二级集合 """ 在集合里面只能放可哈希数据： Number(int,float,complex,bool) str tuple """ setvar = {"a",1,(2,3)} print(setvar) # 二级字典 dictvar = {"a":1,"b":{"c":3,"d":4}} # 多级容器 获取指定元素 container = [1,2,{"a":1,"b":{"c":[33,66,99]}}] res = container[-1] # {'a': 1, 'b': {'c': [33, 66, 99]}} res = container[-1]["b"] # {'c': [33, 66, 99]} res = container[-1]["b"]["c"] # [33, 66, 99] res = container[-1]["b"]["c"][-1] # 99 print(res) # 等长的二级容器 """ 1.里面的每一个元素都是容器类型数据 2.容器里面放的元素个数等长 """ listvar = [(1,2,3),(4,5,6),(7,8,9)] tuplevar = (["a","b"],[1,2],(4,5))
# 转换成字典 dict """ 要求： 1.需要等长的二级容器，并且元素的个数是2个 2.字符串元素个数只能是2个 """ # 外层是列表，里面是列表或者元组或者字符串 listvar = [["a",1],("b",2)] res = dict(listvar) # {'a': 1, 'b': 2} print(res) # 外层是元组，里面是列表或者元组或者字符串 tuplevar = (["a",1],("b",2),"ef") res = dict(tuplevar) # {'a': 1, 'b': 2, 'e': 'f'} print(res) # 外层是集合，里面是元组 setvar = {("a",3.14),("b",3+4j)} res = dict(setvar) # {'a': 3.14, 'b': (3+4j)} print(res) # 外层是元组或者列表，里面是集合。语法可以，违背逻辑，集合无序 container = [{"a",15}] res = dict(container) # {'a': 15} 健无法确定具体哪个 print(res) # 列表去除重复数据，先转集合再转列表。缺点;无序 listvar = ["a","b",1,2,1,"a"] res = list(set(listvar)) # ['b', 'a', 2, 1] print(res) """ 变量的初始化： 下面强转的数据类型，在不给参数的情况下，默认返回一个该数据类型的值 bool() int() float() complex() str() list() tuple() set() dict() """ res = tuple() res = dict() res = set() res = int() print(res)
字典和集合的注意点
哈希算法
#定义:
把不可变的任意长度值计算成固定长度的唯一值,这个值可正可负,可大可小,但长度固定
该算法叫哈希算法(散列算法)，这个固定长度值叫哈希值(散列值)
#特点:
1.计算出来的值长度固定且该值唯一
2.该字符串是密文，且加密过程不可逆
#用哈希计算得到一个字符串的用意？
例如：比对两个文件的内容是否一致？
例如：比对输入的密码和数据库存储的密码是否一致
#字典的键和集合中的值都是唯一值,不可重复:
为了保证数据的唯一性，
用哈希算法加密字典的键得到一个字符串。
用哈希算法加密集合的值得到一个字符串。
如果重复，他们都是后面的替换前面的。自动去重
#版本:
3.6版本之前都是 字典和集合都是无序的
3.6版本之后,把字典的字面顺序记录下来，当从内存拿数据的时候，
根据字面顺序重新排序，所以看起来像有序,但本质上无序
可哈希数据:
可哈希的数据 (不可变的数据)：Number(int float bool complex) str tuple
不可哈希的数据 (可变的数据)： list set dict
python运算符
(1)算数运算符: + - * / // % **
# 算术运算符 # + - * / var1 = 11 var2 = 23 res = var1 + var2 # 34 res = var2 - var1 # 12 res = var2 * var1 # 253 res = var2 / var1 # 2.090909090909091 # 地板除 得到商 得到一个整数 res = var2 // var1 # 2 res = 15//7.0 # 2.0 除数或者被除数是一个小数，结果带上.0 # 取余 res = var2 % var1 # 1 """ 取余时当除数或者被除数里面有负数时： 把正确的余数算出来，前面带上负号即可 """ res = -13 % 7 # -6 + 7 = 1 res = 13 % -7 # 6 + (-7) = -1 res = -13 % -7 # 1 + (-7) = -6 print(res) # 幂运算 res = 2 ** 2 print(res)
(2)比较运算符: > < >= <= == !=
# 比较符运算 > < >= <= == != """ 比较符的运算结果：True或False """ var1 = 15 var2 = 7 res = var1 > var2 # True res = var1 < var2 # False res = var1 == var2 # False """ == 是在做比较，不是在赋值，赋值是一个等号 """ res = var1 != var2 # True print(res)
(3)赋值运算符: = += -= *= /= //= %= **=
# 赋值运算符 = += -= *= /= //= %= **= var1 = 1 var2 = 2 # = var1 = var2 print(var1) # 2 # += var1 += var2 print(var1) # 4 # -= var1 -= var2 print(var1) # 2 # *= var1 *= var2 print(var1) # 4 # /= var1 /= var2 print(var1) # 2.0 # //= var1 //= var2 print(var1) # 1.0 # %= var1 %= var2 print(var1) # 1.0 # **= var1 **= var2 print(var1) # 1.0
(4)成员运算符: in 和 not in (针对于容器型数据)
# 成员运算符 """ in 和 not in（针对于容器数据） 判断字符串时，需要是连续的片段，才能返回值 """ strvar = "Hello" res = "H" in strvar print(res) # True tuplevar = ("a","b","c") res = "b" in tuplevar print(res) # True listvar = ["e","f","g"] res = "e" not in listvar print(res) # False setvar = {"a","b","c"} res = "b" not in setvar print(res) # False """ dict中，in或者not in判断的是字典的健，不是值 """ dictvar = {"a":"1","b":"2"} res = "a" in dictvar # True res = "1" in dictvar # False print(res)
(5)身份运算符: is 和 is not (检测两个数据在内存当中是否是同一个值)
# 身份运算符 """ is 和 is not 检测两个数据在内存中是否同一个值 """ # 1.int类型 在 -5 到正无穷 是同一个内存地址 var1 = 11 var2 = 11 res = var1 is var2 # True print(res) # 比较两个变量的值是否相等 res = var1 == var2 # True print(res) # 2.复数，在只有虚数的情况下，地址相同 var1 = 6j var2 = 6j print(var1 is var2) # True # 3.bool 两个值形同，内存地址一样 var1 = False var2 = True print(var1 is not var2) # True # 4.容器类型数据，只有空元组和相同的字符串，在值相同情况下，地址一样 var1 = () var2 = () print(var1 is var2) # True
(6)逻辑运算符: and or not
# 逻辑运算符 # 1.and 逻辑与 """ 全真则真，一假则假 """ res = False and False print(res) #False res = True and False print(res) #False res = True and True print(res) #True res = False and True print(res) #False # 2.or 逻辑或 全假则假,一真则真 res = True or True print(res) res = True or False print(res) res = False or True print(res) res = False or False print(res) # 3.not 逻辑非 取反 真变假 假变真 res = not True res = not False print(res) # 4.逻辑短路，后面的不执行 """ 1. True or 表达式 2. False and 表达式 """ res = True and 7 print(res) #7 res = False and 8 print(res) #False res = True or 99 print(res) # True res = False or "abc" print(res) #"abc" # 5.逻辑运算优先级 """ () > not > and > or 如果存在逻辑短路，优先计算短路 """ res = 5 or 6 and 7 # 5 res = (5 or 6) and 7 # 7 res = not (5 or 6) and 7 # False print(res) res = 1>2 and 3<4 or 5>6 and 7>8 print(res) # res= False and True or False and False # res= False or False # res = False
(7)位运算符: & | ~ ^ << >>
# & 按位与 var1 = 19 var2 = 15 res = var1 & var2 print(res) """ 10011 01111 00011 """ # | 按位或 res = var1 | var2 print(res) """ 10011 01111 11111 """ # ^ 按位异或 """两个值不相同即为真,相同即为假""" res = var1 ^ var2 print(res) """ 10011 01111 11100 """ # << 左移 """左移是乘 5左移2位相当于 5 * 2的2次幂 = 20""" res = 5 << 2 print(res) """ 0000 ... 101 0000 . 10100 """ # >> 右移 """右移是除 5右移1位相当于 5 // 2的1次幂 = 2""" res = 5 >> 1 print(res) """ 0000 ... 101 0000 ... 010 """ # ~ 按位非 公式: ~19 => -(n+1) res = ~(-18) print(res) """ 总结:所有运算符优先级; 一元运算符: 同一时间,操作一个数据的 (~ -) 二元运算符: 同一时间,操作两个数据的 (+ - * / ...) 一般情况下 , 一元运算符 优先级大于 二元运算符 -3 + 5 = 2 例外: 所有运算符优先级最高的 ** 幂运算 ~2**2 所有运算符优先级最低的 = 赋值运算符 同等级运算符优先级: () > not > and > or 乘除 > 加减 (<< >>) > & > ^ > | 除此之外,大体优先级高低: 算术运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符 赋值运算符 单独列出来 用于把右侧的值算完之后收尾. """ res = ~2**2 print(res) res = 5+5 << 6//3 is 40 and True # 5+5 << 2 is 40 and True # 10 << 2 is 40 and True # 40 is 40 and True # True and True => True print(res) #True # 加上括号提升优先级 让别人也能看懂 res = (5+5) << (6//3) is 40 and True
| python运算符 | 注意点 |
|---|---|
| 算数运算符 | % 取余 ， //地板除 ， ** 幂运算 |
| 比较运算符 | == 比较两个值是否相等 != 比较两个值是否不同 |
| 赋值运算符 | a += 1 => a = a+1 |
| 成员运算符 | in 或 not in 判断某个值是否包含在(或不在)一个容器类型数据当中 |
| 身份运算符 | is 和 is not 用来判断内存地址是否相同 |
| 逻辑运算符 | 优先级 () > not > and > or |
| 位运算符 | 优先级 (<<或 >> ) > & > ^ > | 5 << 1 结果：10 , 5 >> 1 结果：2 |
数据在内存中的缓存机制
在同一文件(模块)里,变量存储的缓存机制 (仅对python3.6版本负责)
# -->Number 部分
1.对于整型而言，-5~正无穷范围内的相同值 id一致
2.对于浮点数而言，非负数范围内的相同值 id一致
3.布尔值而言,值相同情况下，id一致
4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
# -->容器类型部分
5.字符串 和 空元组 相同的情况下，地址相同
6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]
不同文件(模块)里,部分数据驻留小数据池中 (仅对python3.6版本负责 了解)
小数据池只针对：int,str,bool，空元祖(),None关键字 这些数据类型有效
#(1)对于int而言
python在内存中创建了-5 ~ 256 范围的整数,提前驻留在了内存的一块区域.
如果是不同文件(模块)的两个变量,声明同一个值，在-5~256这个范围里，
那么id一致.让两个变量的值都同时指向一个值的地址，节省空间。
#(2)对于str来说:
1.字符串的长度为0或者1，默认驻留小数据池
2.字符串的长度>1,且只含有大小写字母，数字，下划线时，默认驻留小数据池
3.用*号得到的字符串，分两种情况。
1)乘数等于1时: 无论什么字符串 * 1 , 都默认驻留小数据池
2)乘数大于1时: 乘数大于1，仅包含数字，字母，下划线时会被缓存，但字符串长度不能大于20
#（3）指定驻留
# 从 sys模块 引入 intern 函数 让a，b两个变量指向同一个值
from sys import intern
a = intern('大帅锅&*^^1234'*10)
b = intern('大帅锅&*^^1234'*10)
print(a is b)
#可以指定任意字符串加入到小数据池中,无论声明多少个变量,只要此值相同,都指向同一个地址空间
缓存机制的意义
无论是变量缓存机制还是小数据池的驻留机制,都是为了节省内存空间,提升代码效率
以冒号作为开始,用缩进来划分相同的作用域,称之为代码块,代码块是一个整体,一个文件也可称代码块
作用域：作用的区域
流程控制
(1)流程控制的定义
(2)流程控制的结构
分支结构
关键字:if elif else
(1)分支结构的种类
(2)分支结构的特点
# 流程控制 """ 流程:代码执行的过程 流程控制:就是对代码执行的过程进行管控 流程控制的三大结构: 顺序结构: 代码从上到下,依次执行 分支结构: 4小类 循环结构: while , for 分支结构: 关键字 if (1)单项分支 (2)双项分支 (3)多项分支 (4)巢状分支 """ # 单项分支 """ 语法: if 条件表达式: code1 code2 ... ... 如果条件表达式成立,那就是返回真True ,就会执行代码块 如果条件表达式不成立,那就是返回假False,不执行代码块 """ flag = False if flag == False: print("单向分支") # 双项分支: (2个当中选一个) """ if 条件表达式: code1 code2.. else: code3 code4... 如果条件表达式为真,那就是返回真True,执行code1和code2.. 如果条件表达式为假,那就是返回假False,执行code3和code4.. if 下面的代码块也可以叫做真区间 else 下面的代码块也可以叫做假区间 """ flag = True if huanghua == False: print("单向分支") else: print("双向分支") """ 模拟网站的登录 等待用户输入账号和密码; 账户是admin 密码是111 如果条件满足,就让他登录 如果条件不满足,就告诉他登陆失败 """ username = input("请输入您的用户名:") password = input("请输入您的密码:") if username == "admin" and password == "111": print("恭喜你~ 登陆成功") else: print("抱歉,登录失败") # 多项分支 """ if 条件表达式1: code1 code2 elif 条件表达式2: code3 code4... elif 条件表达式3: code5 code6... else: code7 ... """ # 巢状分支 (单项分支 双项分支 多项分支的互相嵌套)
''' 变量 = 条件返回True的结果 if 条件 else 条件返回False的结果 1.必须要有结果 2.必须有if和else 3.只能是简单的情况 ''' x = 3 y = 5 z = x if x > y else y print(z)
循环结构
关键字:while / for..in..
(1)循环结构的种类
(2)循环结构的特点
# 循环结构 """ 特点:可以提升代码执行的效率,减少冗余代码 语法: while 条件表达式: code1... code2.... 如果条件表达式成立,那就返回True,执行代码块里面的内容 如果条件表达式成立,那就返回False,终止循环. """ # 打印1~100; """ # (1) 初始化一个变量i i = 1 # (2) 写一个循环的条件 while i<=100: # (3) 写一个自增自减的值 i+=1 """ i = 1 while i <= 100: print(i) i += 1 # i = i+1 # 计算1~100的累加和? i = 1 total = 0 while i <= 100: total += i # total = i+total i += 1 print(total) # 死循环 """ while True: print(1) """ # 方法二: 做1~100的累加和 print("<====>") i = 1 total = 0 sign = True while sign: total += i i += 1 if i == 101: sign = False print(total) # 5050 # 循环结构练习 # 1.打印一行十个小星星 """ help(print) 查看函数文档 end="" 默认不换行,在最后一个字符的后面插入空字符取代\n """ i = 0 while i<10: print("*",end="") i+=1 # 2.用变量拼接字符串的形式,打印一行十个小星星 i = 0 strvar = "" while i<10: strvar += "*" # strvar = strvar + "*" i+=1 print(strvar) # 3.打印一行十个小星星 奇数个打印★ 偶数个打印☆ """ 0 % 2 = 0 1 % 2 = 1 2 % 2 = 0 3 % 2 = 1 4 % 2 = 0 ... 0 % 3 = 0 1 % 3 = 1 2 % 3 = 2 3 % 3 = 0 4 % 3 = 1 6 % 3 = 2 ... 0 % 8 = 0 1 % 8 = 1 2 % 8 = 2 3 % 8 = 3 4 % 8 = 4 5 % 8 = 5 6 % 8 = 6 7 % 8 = 7 8 % 8 = 0 ..... 1.任意数和n取余 : 值得范围 0~(n-1) """ i = 0 while i < 10: if i % 2 == 0: print("★", end="") else: print("☆", end="") i += 1 # 4.用 一个循环 打印十行十列小星星 i = 0 while i < 100: print("*", end="") 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. 一个循环 打印十行十列隔行变色小星星(一个循环) """ 0 // 3 = 0 1 // 3 = 0 2 // 3 = 0 3 // 3 = 1 4 // 3 = 1 5 // 3 = 1 6 // 3 = 2 7 // 3 = 2 8 // 3 = 2 0 // 4 = 0 1 // 4 = 0 2 // 4 = 0 3 // 4 = 0 4 // 4 = 1 5 // 4 = 1 6 // 4 = 1 7 // 4 = 1 8 // 4 = 2 9 // 4 = 2 10 // 4 = 2 11 // 4 = 2 12 // 4 = 3 .... 2.任意数 和 n进行地板除,会出现n个相同的数字 3.地板除可以获取一个数的高位,取余可以获取一个数的低位 89 // 10 = 8 (高位) 89 % 10 = 9 (低位) """ i = 0 while i<100: if i // 10 % 2 == 0: print("★",end="") else: print("☆",end="") if i % 10 == 9: print() i+=1 # for 循环 """ for 循环专门用来遍历数据, 而while循环遍历数据有局限性,无法遍历无序容器数据 while一般用于复杂的逻辑操作 语法: 可迭代对象:(容器类型数据,range对象,迭代器) for i in 可迭代对象: code.. """ # 1.遍历集合 continer = {"a","b","c"} for i in continer: print(i) # 2. 遍历列表 continer = ["a","b","c"] # 3.遍历元组 continer = ("a","b","c") # 4.遍历字符串 strvar = "Hello world" # 5.遍历字典 默认遍历健 # 6.遍历等长的二级容器 continer = [("a","b"),["c","d"]] for i in continer: print(i) # 变量的解包 a,b = [1,2] print(a,b) a,b,c = (4,5,6) print(a,b,c) a,b = 7,8 print(a,b) # range对象 """ range(start,end,step) start 开始值 end 结束值 (最大值取不到,取到之前的那个值) step 步长 """ # 1.range中只有一个值 for i in range(10): print(i) # 2. range中有二个值 for i in range(1,9): print(i) # 3. range中有三个值 正向值 for i in range(1,15,3): # 1 4 7 10 13 print(i) print("<=============>") # 3. range中有三个值 逆向值 for i in range(15,0,-3): # 1 4 7 10 13 print(i) # 双层循环 # 双层循环练习 # (1)打印十行十列小星星 (用两个循环) # 针对于一行十个星星,循环10次即可 j = 0 # j来控制行数 一共10行 while j < 10: i = 0 while i < 10: print("*", end="") i += 1 # 在打印完一行之后,打印换行; print() j += 1 print("<====>") # (2)打印十行十列隔列换色小星星 j = 0 while j < 10: # 打印星星 i = 0 while i < 10: # 控制打印星星的花色 if i % 2 == 0: print("★", end="") else: print("☆", end="") i += 1 # 打印换行 print() j += 1 # (3)打印十行十列隔行换色小星星 """ 外层j动一次,里面i的循环动10次, 外层动的慢,内层动的快 i和j切换即可; """ print("<====>") j = 0 while j < 10: # 打印星星 i = 0 while i < 10: # 控制打印星星的花色 if j % 2 == 0: print("★", end="") else: print("☆", end="") i += 1 # 打印换行 print() j += 1 # (4)99乘法表 # 方向一 正序 i = 1 while i <= 9: # print(i) # 内层循环,循环几次完全取决于i j = 1 while j <= i: print("%d*%d=%2d " % (i, j, i * j), end="") j += 1 # 打印换行 print() i += 1 # 方向二 倒叙 print("<>=====") i = 9 while i > 0: # print(i) # 内层循环,循环几次完全取决于i j = 1 while j <= i: print("%d*%d=%2d " % (i, j, i * j), end="") j += 1 # 打印换行 print() i -= 1 # (5)100 ~ 999 找吉利数字 111 222 123 321 888 ... """ 789 百位:789 // 100 => 7 十位:789 // 10 % 10 => 8 个位:789 % 10 => 9 """ i = 100 while i <= 999: baiwei = i // 100 shiwei = i // 10 % 10 gewei = i % 10 # 三个相同的数字 if shiwei == gewei and shiwei == baiwei: print(i) # 123 456 789 if shiwei == gewei - 1 and shiwei == baiwei + 1: print(i) # 321 765 876 if shiwei == gewei + 1 and shiwei == baiwei - 1: print(i) i += 1
关键字的使用
pass / break / continue
# break continue # 1.pass """ 如果代码中什么也不写，用pass来进行占位 """ def func(): pass # 2.break终止当前循环（只在循环中使用） # 例：打印1-10如果遇到5就终止循环 i = 1 while i <= 10: print(i) if i == 5: break i += 1 # 3.continue 跳过当前循环，从下一次循环开始（只能在循环中使用） # 例：打印1-10，不包含5 i = 1 while i <= 10: if i == 5: i += 1 continue print(i) i += 1 # 例：打印1-100所有不包含4的数字 # 方法一： i = 1 while i <= 100: if i % 10 == 4 or i // 10 == 4: i += 1 continue print(i) i += 1 # 方法二： i = 1 while i <= 100: num = str(i) if "4" in num: i += 1 continue print(i) i += 1 for i in rang(1,101): num = str(i) if "4" in num: continue print(i)
字符串相关操作
(1)字符串的拼接
(2)字符串的重复
(3)字符串跨行拼接
(4)字符串的索引
(5)字符串的切片:
语法 => 字符串[::] 完整格式：[开始索引:结束索引:间隔值]
(1)[开始索引:] 从开始索引截取到字符串的最后
(2)[:结束索引] 从开头截取到结束索引之前(结束索引-1)
(3)[开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1)
(4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取字符
(5)[:]或[::] 截取所有字符串
# 1.字符串的拼接 + s1 = "Hello" s2 = "world" res = s1 + s2 print(res) # 2.字符串的重复 * strvar = "abc" res = strvar * 3 print(res) # 3.字符串的跨行拼接 \ strvar = "abc"\ "efg" print(strvar) # 4.字符串的索引 strvar = "人生苦短，我用python" res = strvar[1] res = strvar[-2] print(res) # 5.字符串的切片，字符串的截取 # (1)[开始索引:] 从开始索引截取到字符串的最后 res = strvar[3:] print(res) # (2)[:结束索引] 从开头截取到结束索引之前(结束索引-1) res = strvar[:8] print(res) # (3)[开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1) res = strvar[5:10] # 最大下标10取不到 print(res) # (4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取字符 res = strvar[::3] print(res)
字符串的格式化format
(1)顺序传参
(2)索引传参
(3)关键字传参
(4)容器类型数据(列表或元祖)传参
(5)format的填充符号的使用( ^ > < )
(6)进制转换等特殊符号的使用( :d :f :s :, )
# 字符串格式化的传参方式 """ {} 是format语法中的占位符 """ # 1.顺序传参 strvar = "编程语言{}、{}" strvar = strvar.format("python",'java') print(strvar) # 2.索引传参 strvar = "买了一本{1},价格{0}" res = strvar.format("99","流畅的python") print(res) # 3.关键字传参 strvar = "人生苦短，我用{obj}" res = strvar.format(obj="python") print(res) # 4.容器类型数据（列表或元组）传参 strvar = "{0[1]} 和 {1[2]}" res = strvar.format(["a","b","c"],("e","f","g")) print(res) # format中如果是获取字典的值不要加上引号 strvar = "{group2[value1]},{group1[1]}" res = strvar.format(group1=["a","b","c"],group2={"value1":1,"value2":2}) print(res) # format 字符串填充 """ format填充符号的使用 ^ 原字符串居中 > 原字符串居右 < 原字符串居左 语法: {who:*>10} * 要填充的字符 > 原字符串居右 10 原字符个数+要填充的个数 = 长度10 """ strvar = "{obj:*^10},{obj2:!<10},{obj3:>>5}" res = strvar.format(obj="python",obj2="java",obj3="php") print(res) # 进制转换等特殊符号的使用( :d :f :s :, ) """ :d 整型占位符 :f 浮点型占位符 :s 字符串占位符 :, 金钱占位符 """ strvar = "在{:s}买了{:d}苹果，价格{:.2f}" res = strvar.format("沃尔玛",3,15.5) print(res)
字符串相关函数
*capitalize 字符串首字母大写
*title 每个单词的首字母大写 (非字母隔开的单词)
*upper 将所有字母变成大写
*lower 将所有字母变成小写
*swapcase 大小写互换
*count 统计字符串中某个元素的数量
*find 查找某个字符串第一次出现的索引位置
*index 与 find 功能相同 find找不到返回-1,index找不到数据直接报错
*startswith 判断是否以某个字符或字符串为开头
*endswith 判断是否以某个字符或字符串结尾
*split 按某字符将字符串分割成列表(默认字符是空格)
*join 按某字符将列表拼接成字符串(容器类型都可)
*replace 替换字符串(可选择替换的次数)
#isupper 判断字符串是否都是大写字母
#islower 判断字符串是否都是小写字母
#istitle 判断字符串是否每个单词都首字母大写
*isalnum 判断字符串是否是由数字、字母、汉字组成
#isalpha 判断字符串是否由字母和文字组成
*isdigit 检测字符串数是数字组成 接受二进制字节流
*isdecimal 检测字符串是否以数字组成 必须是纯数字
#isnumeric 检测字符串是否以数字组成 接受中文"四"
#isspace 判断字符串是否由空白符组成
*len 计算容器类型长度
#splitlines 按换行来进行切分(\n)
#zfill 填充字符串(默认填充0,原字符串右对齐)
#ljust 填充字符串,原字符居左 (默认填充空格)
#rjust 填充字符串,原字符居右 (默认填充空格)
*center 填充字符串,原字符居中 (默认填充空格)
*strip 默认去掉首尾两边的空白符
#rstrip 去掉右边某个字符
#lstrip 去掉左边某个字符
#maketrans translate 是一对
maketrans()
功能: 制作用于字符串替换的映射表
格式: 字符串.maketrans('查找字符','替换字符')两个字符必须长度相等
返回值: 字典
translate()
功能: 进行字符串替换操作
格式: 字符串.translate(maketrans返回的字典)
返回值: 替换之后的字符串
# 字符串的函数 print("python".capitalize()) print("python java".title()) print("python".upper()) print("python".lower()) print("Python".swapcase()) print("python".count("o")) print("python".find("y")) print("python".index("o")) print("python".startswith("p")) print("python".endswith("n")) print("python|java|php".split("|")) print("-".join(["a","b"])) print("python".replace("py","Py")) print("中ab12".isalnum()) print("python ".strip())
(1)列表的拼接 (同元组)
(2)列表的重复 (同元组)
(3)列表的切片 (同元组)
语法 => 列表[::] 完整格式：[开始索引:结束索引:间隔值]
(1)[开始索引:] 从开始索引截取到列表的最后
(2)[:结束索引] 从开头截取到结束索引之前(结束索引-1)
(3)[开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1)
(4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
(5)[:]或[::] 截取所有列表
(4)列表的获取 (同元组)
(5)列表的修改 ( 可切片 )
(6)列表的删除 ( 可切片 )
# 1.列表的拼接 res = ["a","b"] + [1,2] print(res) # 2.列表的重复 print(["a","b"]*3) # 3.列表的切片 listvar = ["a","b","c",1,2,3] print(listvar[3:]) # 开始索引到最后 print(listvar[:4]) # 从开头截取到结束索引 print(listvar[2:4]) # 开始到结束 print(listvar[5:0:-2]) # 逆向截取 print(listvar[:]) # 截取所有 print(listvar[::]) # 截取所有 # 4.列表的获取 通过索引获取 print(listvar[3]) print(listvar[-1]) # 获取最后一个 # 5.列表的修改（可切片） listvar[0] = "A" # 5.1 截取数据去除，可迭代数据中元素依次进行赋值 listvar = ["a","b","c"] listvar[1] = [1,2,3] print(listvar) # 5.2 切片加步长，切几个元素就放几个元素，个数要匹配 listvar = ["a","b","c","d","e","f"] listvar[1:4] = [1,2,3] print(listvar) # 6.列表的删除 可切片 del关键字删除 listvar = ["a","b","c"] del listvar[1] print(listvar)
列表的相关函数
append()
功能：向列表的末尾添加新的元素
格式：列表.append(值)
返回值：None
注意：新添加的值在列表的末尾，该函数直接操作原有列表
# append() listvar = [1,2,3] listvar.append(4) print(listvar)
insert()
功能：在指定索引之前插入元素
格式：列表.insert(索引,值)
返回值:None
注意：直接改变原有列表
# insert() listvar = [1,2,3] listvar.insert(1,4) print(listvar) # [1, 4, 2, 3]
extend()
功能：迭代追加所有元素
格式：列表.extend(可迭代性数据)
返回值：None
注意：直接改变原有列表
# extend() listvar = [1,2,3] listvar.extend((4,5,6)) print(listvar) # [1, 2, 3, 4, 5, 6]
pop()
功能：通过指定索引删除元素,若没有索引移除最后那个
格式：列表.pop(索引)
返回值：删除的元素
(注意：没有指定索引，默认移除最后一个元素 )
# pop() listvar = [1,2,3] listvar.pop(1) print(listvar) # [1, 3]
remove()
功能：通过给予的值来删除,如果多个相同元素,默认删除第一个
格式：列表.remove(值)
返回值：无
(注意：如果有索引的情况推荐使用pop,效率高于remove)
# remove() listvar = [1,2,3] listvar.remove(2) print(listvar) # [1, 3]
clear()
功能：清空列表
格式：列表.clear()
返回值：空列表
# clear() listvar = [1,2,3] listvar.clear() print(listvar) # []
index()
功能：获取某个值在列表中的索引
格式：列表.index(值[,start][,end]) # [] 表达参数可选项
返回值：找到返回索引 (找不到报错)
# index() listvar = [1,2,3,1,2,3,1,2,3] res = listvar.index(2,4) print(res)
count()
功能：计算某个元素出现的次数
格式：列表.count(值)
返回值：次数
# count() listvar = [1,2,3,1,2,3,1,2,3] res = listvar.count(2) print(res)
sort()
功能：列表排序(默认小到大排序)
格式：列表.sort(reverse=False)
返回值：None
注意：直接更改原列表
# sort() listvar = [3,1,5,9,7] listvar.sort() print(listvar)
reverse()
功能：列表反转操作
格式：列表.reverse()
返回值：None
注意：直接更改原列表
# reverse() listvar = [3,1,5,9,7] listvar.reverse() print(listvar)
深拷贝浅拷贝
copy模块中有 浅拷贝 和 深拷贝 两种方法
(1)浅拷贝: 浅拷贝只拷贝外层列表 内层列表跟随原列表进行改变
浅拷贝copy.copy(listvar) 或者 listvar.copy()
(2)深拷贝: 拷贝整个列表 内外列表都不跟随原列表进行改变
深拷贝copy.deepcopy(listvar)
注意:copy模块的copy方法 和 python内置的函数copy一样 都是浅拷贝
''' 赋值运算: list1与list2指向的是同一个内存地址，他们完全一样 ''' list1 = [1,2,'A',['python','java']] list2 = list1 list1[2] = 'B' # 修改列表中元素 print(list1,id(list1)) print(list2,id(list2)) list1[3][1] = 'php' # 修改列表中嵌套列表 print(list1,id(list1)) print(list2,id(list2)) ''' 浅copy： 第一层建的是新的内存地址，第二层指向的都是同一个内存地址 对于第二层及更深的层数来说，保持一致性 ''' list1 = [1,2,'A',['python','java']] list2 = list1.copy() print(list1,id(list1)) print(list2,id(list2)) list1[2] = 'B' print(list1,id(list1)) print(list2,id(list2)) list1[3][1] = 'php' print(list1,id(list1[3])) print(list2,id(list2[3])) # 浅copy案例,联名账户 账户中余额都可以看到 账户名不改变 person = ['name',['balanec',100]] p1 = person.copy() p2 = person.copy() p1[0] = 'A' p2[0] = 'B' print(p1) print(p2) p1[1][1] = 50 print(p1) print(p2) ''' 深拷贝deepcopy： 对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变 ''' import copy # 导入copy模块 list1 = [1,2,'A',['python','java']] list2 = copy.deepcopy(list1) print(list1,id(list1)) print(list2,id(list2)) list1[2] = 'B' print(list1,id(list1)) print(list2,id(list2)) list1[3][1] = 'php' print(list1,id(list1[3])) print(list2,id(list2[3]))
元组相关操作和方法
元组的相关操作除了不能修改和删除其中的元素之外 , 剩下操作都和列表相同.
元组里面能用的方法只有 index 和 count
#fromkeys() 使用一组键和默认值创建字典
#pop() 通过键去删除键值对 (若没有该键可设置默认值,预防报错)
#popitem() 删除最后一个键值对
#clear() 清空字典
#update() 批量更新(有该键就更新,没该键就添加)
#get() 通过键获取值(若没有该键可设置默认值,预防报错)
#keys() 将字典的键组成新的可迭代对象
#values() 将字典中的值组成新的可迭代对象
#items() 将字典的键值对凑成一个个元组,组成新的可迭代对象
# 字典相关操作 # 1.增 dictvar = {} dictvar["a"] = 1 print(dictvar) # fromkeys() 使用一组键和默认值创建字典 (返回新字典) listvar = ["a","b","c"] dictvar = {}.fromkeys(listvar,None) print(dictvar) # fromkeys 不推荐使用,三个键所指向的是同一个列表; dictvar = {}.fromkeys(listvar,[1,2,3]) print(dictvar) dictvar["a"].append(4) print(dictvar) # 2.删 # 2.1 pop() dictvar = {"a":1,"b":2,"c":3} dictvar.pop("d","不存在该健值") # 返回值提示 print(dictvar) # 2.2 popitem() 删除最后一个健值对 dictvar = {"a":1,"b":2,"c":3} dictvar.popitem() print(dictvar) # 2.3 clear() 清空字典 dictvar = {"a":1,"b":2,"c":3} dictvar.clear() print(dictvar) # 3. 改 # updae() 批量更新，有该健就更新，没有就添加 dictvar = {"a":1,"b":2,"c":3} dictvar.update({"a":11,"d":4}) print(dictvar) dictvar.update(e="6") print(dictvar) # 4 查 # get() dictvar = {"a":1,"b":2,"c":3} res = dictvar.get("b") print(res) # keys() 将字典的健组成新的可迭代对象 dictvar = {"a":1,"b":2,"c":3} res = dictvar.keys() print(res) # dict_keys(['a', 'b', 'c']) # values() 将字典中的值组成新的可迭代对象 res = dictvar.values() print(res) # items() 将字典的键值对凑成一个个元组,组成新的可迭代对象 res = dictvar.items() print(res)
集合中的交差并补
#intersection() 交集
#difference() 差集
#union() 并集
#symmetric_difference() 对称差集 (补集情况涵盖在其中)
#issubset() 判断是否是子集
#issuperset() 判断是否是父集
#isdisjoint() 检测两集合是否不相交 不相交 True 相交False
setvara = {1,2,3,4,5}
setvarb = {4,5,6,7,8}
# intersection() 交集
res = setvara.intersection(setvarb)
print(res)
# 简便写法 &
print(setvara & setvarb)
# difference() 差集
print(setvara.difference(setvarb))
print(setvara - setvarb)
# union() 并集
print(setvara.union(setvarb))
print(setvara | setvarb)
# symmetric_difference() 对称差集
print(setvara.symmetric_difference(setvarb))
print(setvara ^ setvarb)
# issubset() 判断是否是子集
setvara = {1,2}
setvarb = {1,2,3,4}
print(setvara.issubset(setvarb))
print(setvara < setvarb)
print(setvara <= setvarb)
# issuperset() 判断是否是父集
print(setvarb.issuperset(setvara))
print(setvarb > setvara)
# 检测两集合是否不相交 相交False
print(setvarb.isdisjoint(setvara))
集合相关的函数
#add() 向集合中添加数据
#update() 迭代着增加
#clear() 清空集合
#pop() 随机删除集合中的一个数据
#remove() 删除集合中指定的值(不存在则报错)
#discard() 删除集合中指定的值(不存在的不删除 推荐使用)
# 1.增 # 1.1 add() setvar = {1,2,3} setvar.add(4) print(setvar) # 1.2 update() 迭代添加 setvar.update([4,5,6]) print(setvar) # 2.删 setvar = {1,2,3,4,5} # pop() 随机删除 setvar.pop() print(setvar) # remove() 删除指定的值（不存在报错） setvar = {1,2,3,4,5} setvar.remove(3) print(setvar) # discard() 删除集合中指定的值（不存在不删除） setvar = {1,2,3,4,5} setvar.discard(33) print(setvar) # clear() 清空集合 setvar.clear() print(setvar)
冰冻集合
#frozenset 可强转容器类型数据变为冰冻集合
冰冻集合一旦创建,不能在进行任何修改,只能做交叉并补操作
# 冰冻集合 """ frozenset 可强转容器类型数据变为冰冻集合 冰冻集合一旦创建,不能在进行任何修改,只能做交叉并补操作 """ # 定义一个空的冰冻集合 fz = frozenset() print(fz) # 强制转换为一个冰冻集合 listvar = {1,2,3} fz = frozenset(listvar) print(fz) for i in fz: print(i)
#打开模式
w write 写入模式
文件不存在则创建文件,存在的话则打开清空内容,并且将文件指针放在文件的开头
r read 读取模式
文件不存在则报错! 存在的话则打开文件，并且将文件指针放在文件的开头
a append 追加模式
文件不存在则创建文件,存在的话则打开文件,*并且将文件指针放在文件的末尾*
x xor 异或模式
文件已存在则报错! 不存在的话则创建文件,将文件指针放在文件的开头
#扩展模式 (配合打开模式的辅助模式,自己单独不能使用)
+ plus 增强模式(可以让文件具有读写功能)
b bytes bytes模式(二进制字节流)
#模式一共16种
w,w+,wb,wb+
r,r+,rb,rb+
a,a+,ab,ab+
x,x+,xb,xb+
# 将字符串和字节流(Bytes流)类型进行转换 (参数写成转化的字符编码格式)
#encode() 编码 将字符串转化为字节流(Bytes流)
#decode() 解码 将Bytes流转化为字符串
# (utf-8编码格式下 默认一个中文三个字节 一个英文或符号 占用一个字节)
#read() 功能: 读取字符的个数(里面的参数代表字符个数)
#seek() 功能: 调整指针的位置(里面的参数代表字节个数)
#tell() 功能: 当前光标左侧所有的字节数(返回字节数)
# 刷新缓冲区 flush
# 当文件关闭的时候自动刷新缓冲区
# 当整个程序运行结束的时候自动刷新缓冲区
# 当缓冲区写满了 会自动刷新缓冲区
# 手动刷新缓冲区
with语法
# with 语法 自动关闭文件 相当于帮你执行了fp.close()
文件相关函数
#readline() 功能: 读取一行文件内容
#readlines() 功能：将文件中的内容按照换行读取到列表当中
#writelines() 功能：将内容是字符串的可迭代性数据写入文件中 参数:内容为字符串类型的可迭代数据
#truncate() 功能: 把要截取的字符串提取出来,然后清空内容将提取的字符串重新写入文件中 (字节)
#readable() 功能: 判断文件对象是否可读
#writable() 功能: 判断文件对象是否可写
''' 文件操作： 1.文件路径 2.编码方式 utf-8 gbk 3.操作方式：只读、只写、追加、读写、写读 以什么编码方式存储的文件，就以什么编码方式打开进行操作 ''' # 读 以bytes打开，显示是unicode 转换为了str f = open('a',mode='r',encoding='utf-8') data = f.read() print(data,type(data)) print(f,type(f)) # 一个文件句柄 f.close() # rb 以rb方式打开时不需要加编码参数，非文字类的文件，以bytes类型方式读出来 f = open('a',mode='rb') data = f.read() print(data,type(data)) f.close() # 写 w ,对于写没有次文件就创建文件，先将原文件全部清除，再写 f = open('log',mode='w',encoding='utf-8') f.write('vs php') f.close() # 写 wb f = open('log',mode='wb') # wb写的是bytes类型，不需要编码方式 f.write('php学习'.encode('utf-8')) ''' str需要转换为bytes类型 需要以文件的编码方式写入，以gbk会乱码 ''' f.close() # a 追加 f = open('log',mode='a',encoding='utf-8') f.write('python学习') f.close() # ab 以bytes类型追加进去 f = open('log',mode='ab') f.write('java学习'.encode('utf-8')) f.close() # r+ 读写 f = open('log',mode='r+',encoding='utf-8') data = f.read() print(data) f.write('python9') # 读完光标在最后 print(f.read()) # 不会在进行读 f.close() ''' r+模式下先写再读: 因为光标在最前面，写多少占多少位 ''' f = open('log',mode='r+',encoding='utf-8') f.write('aaaaaa') print(f.read()) f.close() ''' r+b:读写以bytes类型，可以写可以不写 ''' f = open('log',mode='r+b') print(f.read()) # f.write('aaaaaa'.encode('utf-8')) f.close() ''' w+:写读，先清除后写 ''' f = open('log',mode='w+',encoding='utf-8') f.write('efg') f.seek(0) # 将光标调到最开始位置 print(f.read()) f.close() ''' a+:写读 ''' f = open('log',mode='a+',encoding='utf-8') f.write('abcdeft') f.seek(0) # 需要传入参数 print(f.read()) f.close() ''' 功能详解 ''' f = open('log',mode='r+',encoding='utf-8') data = f.read(3) # 读多少个字符 print(data) f.close() ''' seek 调整光标,是按照字节去定光标的位置 以中文为例：光标设置7个字节编码为utf-8时到两个字符以后 read两个字符时就会报错 ''' f = open('log',mode='r+',encoding='utf-8') f.seek(7) # 找光标是按字节 data = f.read(2) # 读多少个字符，中文会报错 print(data) f.close() # 查看光标位置 f = open('log',mode='r+',encoding='utf-8') f.seek(3) # 找光标是按字节 print(f.tell()) # 光标的位置 f.close() # 追加后调节光标位 f = open('log',mode='a+',encoding='utf-8') f.write('java') count = f.tell() f.seek(count - 3) # 光标往前移多少位 print(f.read()) print(f.readable()) # 是否可读 print(f.readline()) # 一行一行读 f.close() f = open('log',mode='r+',encoding='utf-8') print(f.readable()) # 是否可读 print(f.readline()) # 一行一行读 print(f.readlines()) # 每一行当成列表中的一个元素，添加到列表中 f.close() f = open('log',mode='r+',encoding='utf-8') f.seek(1) print(f.truncate(5)) # 对原文件截取 f.seek(0) print(f.read()) # 查看截取后的原文件 f.close() #for循环，大文件需要一行一行读写，不能全部用for循环读写 f = open('log',mode='r+',encoding='utf-8') for line in f: # for循环查看文件 print(line) f.close() # with 语句 管理上下文，自动关闭文件 with open('log',mode='r+',encoding='utf-8') as f1,\ open('a',mode='r+',encoding='utf-8') as f2: print(f1.read()) print(f2.read()) # 文件修改 with open("source_file",'r',encoding="utf-8") as f1,open("source_file.bak",'w',encoding="utf-8") as f2: for line in f1: if "python" in line: line = line.replace("python","java ") f2.write(line) import os os.remove('source_file') # 删除文件 os.rename('source_file.bak','source_flie')
字符相关的(了解)
字符：无论是什么语言,独立的一个文字就是一个字符
存储单位:
Byte字节
bit:位
1B = 8b
B：字节, 1Byte = 8bit
字符大小:
无论何种字符集：英文和数字都是一个字节，汉字，韩文，日文等亚洲文字采用多个字节存储
GB系列编码：存储一个汉字使用2个字节 (国标编码:例如: gbk2312 )
UTF系列编码：存储一个汉字使用3个字节(国际通用:例如: utf-8 )
字符编码种类: (把编码看成一个密码本,每一个字符在计算机中都是个二进制)
英文原始编码：
ASCII码 -> 最早的字符编码格式->仅支持英文和特定的符号
中文编码：
GB2312 ： 包含5000个常用汉字的标准
GB18030： 升级版本的标准，大概15000个汉字
GBK ： 包含所有中文汉字的编码（推荐）
BIG5 ： 繁体中文编码
万国码:
unicode 包含世界上所有的文字(无论什么字符 都按照4个字节表示)
utf-8 可变长的unicode编码
