Python基础1 （基本数据类型 文件）
Python简介
应用领域
web开发（写网站从无到有）人工智能 爬虫（大批量爬取网络中的数据）金融分析 云计算
Python2 和 Python3 的区别
Python2 源码不统一 重复代码
Python3 源码统一 没有重复代码
Python2的input获取到的是什么类型就是什么类型
Python3的input获取到的全都是字符串
Python2不支持中文 print可以不加括号
编程语言
编译型和解释型 静态语言和动态语言 强类型定义语言和弱类型定义语言
编译型(代表 C)
优点： 运行速度快 缺点：开发效率慢
解释型(代表 Python)
优点：开发效率快 缺点：运行速度慢
Python的优缺点
优点
-
简单易懂
-
开发效率非常高，类库（第三方库）特别多
-
高级语言，无需考虑内存等底层细节
-
可移植性，可跨平台
-
可扩展性，在Python中把部分程序用C或C++编写
-
可嵌入性，Python可嵌入C或C++
缺点
-
速度慢
-
代码不能加密
-
线程不能利用多CPU
Python的种类
Cpython（Python转C语言） Jyhton （Python转java） IronPython （Python转C#）
PyPy（Python转Python编译）（特殊）
Python的入门
变量 -- 输出
a = 1 # 声明变量
a # 变量的名字
= # 赋值
1 # 值
变量定义的规则
1.变量由数字,字母,下划线组成
2.不能以数字开头
3.不能使用python中关键字 (and,as,assert,break,class,continue,def,del,elif,else,except,exec,finally,for,from,global,if,import,in,is,lanbda,not,or,pass,print,raise,return,try,while,with,yield)
4.不能使用中文和拼音
5.区分大小写
6.变量名要具有描述性
7.推荐写法
7.1驼峰体
7.2下划线 age_of_oldboy = 98 (官方推荐)
变量的小高级
age = 18
age1 = 19
age2 = age # age2 = 18
age = 20
print(age,age1,age2) #20 19 18 一个变量名只能代指一个值
a = 4
b = a + 6 #在声明变量的时候先执行等号右边的内容
print(b) # 10
常量
常量:ID = 11012013014066 常量就是不变的量
常量名全部大写
注释
单行注释 #
多行注释 """ """ ''' '''
被注释的内容是不是会执行的
基础数据类型
type(类型)
数字： 用于计算和比较(int)
字符串：在python中只要是用引号引起来的就是字符串(str)
加法 -- 同是字符串才能相加
乘法 -- 只能和数字进行相乘
''' I'm "meet" ''' #引号配合使用
a = 'alex'
b = 'wusir'
print(a+b) # alexwusir 字符串拼接 注意:只能和字符串相加
a = '坚强'
print(a*8) #坚强坚强坚强坚强坚强坚强坚强坚强 字符串乘 注意:只能和数字相乘
布尔值：返回真假值 用于判断(bool)
True 真
False 假
程序交互
注意:input获取到的内容全都是字符串
int() -- 将字符串中的数字转换成整型
type() -- 查看数据类型
if
if 判断条件：
执行语句……
else：
执行语句……
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……
while 循环
while -- 关键字 (死循环)
while 条件：
循环体
while 判断条件(condition)：
执行语句(statements)……
while else
while True:
print(111)
break
else:
print(222)
while True:
print(111)
break
print(222)
总结：
打断循环的方式：
1.自己修改条件
2.breakbreak -- 打破当前循环 （终止当前循环）
continue -- 跳出当前循环继续下次循环（将
continue伪装成循环体中的最后一个行代码）break和
continue相同之处：他们以下的代码都不执行
for 循环
for iterating_var in sequence:
statements(s)
字符串格式化
print "My name is %s and weight is %d kg!" % ('Zara', 21)
My name is Zara and weight is 21 kg!
运算符
算术运算符
| 符号 | 名称 |
|---|---|
| + | 加 |
| - | 减 |
| * | 乘 |
| / | 除 |
| % | 模 |
| ** | 幂运算 |
| // | 整除 |
赋值运算符
| 符号 | 名称 |
|---|---|
| += | 加等于 |
| -= | 减等于 |
| *= | 乘等于 |
| /= | 除等于 |
| //= | 整除等于 |
| **= | 幂等于 |
| %= | 模等与 |
比较运算符
== 判断等号两端的值是否相同
is判断判断内存地址是否相同
| 符号 | 名称 |
|---|---|
| > | 大于 |
| < | 小于 |
| >= | 大于等于 |
| <= | 小于等于 |
| == | 等于 |
| ！= | 不等于 |
成员运算符
| 符号 | 名称 |
|---|---|
| in | 在 |
| not in | 不在 |
逻辑运算符
| 符号 | 名称 | |
|---|---|---|
| and | 与 | 前后都为真取后者，前后都为假取前者，一真一假取假 |
| or | 或 | 前后都为真取前者，前后都为假取后者，一真一假取真 |
| not | 非 |
成员运算符
in 存在 not in 不存在
编码初识
ascii （老美）不支持中文
gbk (国标) 英文 8位 中文16位
unicode （万国码）英文2字节 16 位 中文4字节 32位
utf-8 （可变长的编码） 英文1字节8位 欧洲文2字节16位 亚洲3字节24位
linux -- utf-8
mac -- utf-8
windows -- gbk
单位转换：
1字节 = 8位
1Bytes = 8bit
1024Bytes = 1KB
1024KB = 1MB
1024MB = 1GB
**1024GB = 1TB ** TB就够用了
1024TB = 1PB
1024PB = 1EB
整型以及布尔值转换
整型 -- 数字 (int)
整型（数字）用于比较和运算
计算机支持的数字范围
32位 -- -2 ** 31 ~ 2 ** 31 -1
64位 -- -2 ** 63 ~ 2 ** 63 -1
Python2和Python3在整型中的区别
python2 整型 int -- long(长整型) /获取的是整数 python3 整型 int / 获取的是浮点数(小数)
二进制和十进制
456 ----- 十进制数0101 ----- 二进制数除此之外还有：十六进制 八进制 二进制
bool() 布尔值
print(bool(1)) # 数字非零的就是True 零就是Falseprint(bool("")) # 字符串不为空就是True(有空格也是不为空) ,字符串中没有任何内容就是False
字符串详解
在python中引号引起来就是字符串
字符串是用来存储少量数据
name = "m e a t"
# meat 每一个字母叫做一个元素
# 0 1 2 3 从左向右 #-4-3-2-1 从右向左
# 索引(下标) 通过索引可以精确的定位到某个元素print(name[-1])
# t
切片
name = " 今天是个 好日子"
# 0 1 2 3 4 5 6
#-7-6-5-4-3-2-1a = name[0]
#今b = name[1]
#天print(a+b)
#今天print(name[0:2])
# 顾头不顾尾 name[起始位置:终止位置]print(name[:])
# 某个位置不指定的时候默认取最后或最前print(name[2:5])
# 是个好print(name[-4:-1])
# 个好日print(name[-2:-5])
# 输出为空print(name[-2:-5:-1])
# [起始位置:终止位置:步长] 步长默认为1 例：name = "大黑哥吃大煎饼"print(name[1:5])
#黑哥吃大print(name[-2:-6:-1])
#哥吃大煎print(name[-6:6])
#黑哥吃大取第1.3.5.7位置的字a = name[0]b = name[2]c = name[4]d = name[6]print(a+b+c+d)运用步长：print(name[::2])
#步长为2，所以每两个取一个print(name[100:105])
#切片的时候起始位置和终止位置都超出的时候不会进行报错print(name[100])
#索引的时候索引值超出范围的时候会报错 练习：s = 'Python最NB'获取s字符串中前3个内容print(s[:3])获取s字符串中第3个内容print(s[2])获取s字符串中后3个内容print(s[-3:])获取s字符串中第3个到第8个print(s[2:-1])获取s字符串中第2个到最后一个print(s[1:])获取s字符串中第1,3,5个内容print(s[:5:2])获取s字符串中第2,4,6个内容print(s[1:6:2])获取s字符串中所有内容print(s)获取s字符串中第4个到最后一个,每2个取一个print(s[3::2])获取s字符串中倒数第5个到最开始,每3个取一个 print(s[-5::-3])
字符串的方法:
| 方法 | 描述 | 代码 |
|---|---|---|
| upper() | 将字符串转换为大写 | "abc".upper() |
| lower() | 将字符串转换为小写 | "ABC".upper() |
| startswith() | 查询以什么开头返回bool类型 | "abc".startswith("a")"abc".startswith("b",1) |
| endswith() | 查询以什么结尾返回bool类型 | "abc".endswith("a")"abc".endswith("b",0,2) |
| count() | 统计指定内容出现次数 | "aaba".count("a") |
| strip() | 去除两段的空格、换行符、制表符(可指定内容) | print(" a ".strip()"abc".strip("a") |
| split() | 以空格、制表符、换行符进行分割(可指定内容以及最大分割块)返回一个数组 | "a b c ".split(maxsplit=2) |
| replace() | 替换字符串中的内容，(可以指定替换次数) | "abc".replace("b","c",1) |
| isalnum() | 判断是否为子母、数字、中文 | "a2三".isalnum() |
| isalpha() | 判断是否为字母，中文 | "a三".isalpha() |
| isdigit() | 判断是否为阿拉伯数字 | "12③".isalnum() |
| isdecimal() | 判断是否为十进制的数字 | ”123".isdecimal() |
| len() | 获取字符串长度 | "abc".len() |
| capitalize() | 将字符串首字母大写 | "abc".capitalize() |
| title() | 将字符串每个单词首字母大写 | "a b c".title() |
| swapcase() | 将字符大小写反转 | "aBc".swapcase() |
| center() | 居中填充 | "abc".center(15,"-") |
| find() | 查找，当不存在的时候返回-1(返回值为下表) | "abc".find("b") |
| index() | 查找，当不存在提示错误 | "abc".index("b") |
| join() | 使用指定内容拼接 | "^".join("abc") |
S系列
s = "ALEX"s1 = s.upper()
#全部大写print(s1)s1 = s.lower()
# 全部小写print(s1)应用场景
s = input("验证码(AbC5)")
if s.upper() == "AbC5".upper():
print("验证码正确")
else:
print("验证码错误!")
以....开头:
s = "ALEX"s1 = s.startswith("A")
print(s1)
#Trues1 = s.startswith("E",2,6)print(s1)
#True以....结尾:
s = "ALEX"s1 = s.endswith("X")
print(s1) #True
统计s = "alexdxjbx"s1 = s.count("x")print(s1)
# 3脱: 字符串头尾两端的空格和换行符以及制表符n = input(">>>")if n.strip() == "alex": print("1")else: print("2")
#输入" alex " 输出"1"s = "alexdsba"s1 = s.strip("a")
# 可以指定内容取脱print(s1)
# lexdsb分割:以空格和换行符以及制表符进行分割s = "aelxlaaa"s1 = s.split("l")
# 可以通过指定方式进行切割 print(s1)
# "ael","laaa"s = "aelxlaxaa"s1 = s.split("l",maxsplit=1)
# 存在多个可切割目标时，可用maxsplit来指定切割次数，maxsplit=1即切割次数为1print(s1)
# "ael","laxaa"s = "aelxlaxaa"s1 = s.rsplit("l",maxsplit=1)
# 存在多个可切割目标时，用maxsplit指定切割次数后，可在split前加"r"来更改切割优先方向print(s1)
# "aelx","laaa"替换:s = "大黑哥吃肉夹馍"s1 = s.replace("肉夹馍","大煎饼")print(s1)
# 大黑哥吃大煎饼s = "大黑哥吃肉夹馍,肉夹馍"s1 = s.replace("肉夹馍","大煎饼",1)
# 指定替换的次数print(s1)
#大黑哥吃大煎饼,肉夹馍补充
str:
不可变数据
1.首字母大写:
name = "alex"name1 = name.capitalize()print(name1)
2.每个单词首字母大写:
name = "alex wusir"print(name.title())
3.大小写反转
name = "Alex"print(name.swapcase())
4.居中 -- 填充
name = "alex"print(name.center(20,"-"))
5.查找
从左向右 只查找一个name = "alelx"print(name.find("b")) #find查找不存在的返回-1 存在返回"0"print(name.index("b")) #index查找不存在的就报错,,存在的返回索引值
6.拼接
name = "al3x"print("_".join(name))
7.格式化
① %s② f''③ name.format()name = "alex{},{},{}"print(name.format(1,2,3))
# 按照顺序位置进行填充name = "alex{2},{0},{1}"print(name.format("a","b","c"))
# 按照索引值进行填充name = "alex{a},{b},{c}"print(name.format(a=1,c=11,b=67))
# 按照关键字进行填充
8.字符串的 加 和 乘
开辟新的内存空间
name = "alex"name1 = "wusir"
print(name)print(name1)
print(name + name1)
is系列
s = "12.3"print(s.isalnum())
# 判断是不是字母,数字,中文print(s.isalpha())
# 判断是不是字母,中文print(s.isdigit())
# 判断字符串是不是全都是阿拉伯数字print(s.isdecimal())
# 判断是否是十进制
列表
定义
列表--list--容器
有序,可变,支持索引.
列表:存储数据类型很多,字符串,数字, 布尔值,列表,集合,元祖,字典.
定义一个列表:
lst = ["dsb",123,True,"黑哥"]
# 用逗号分隔的是一个元素获取对象的内存地址(id)print(lst[0])
# dsbprint(id(lst[0])) # 2354942210432 lst[0] = "dsb"print(lst)
# ['dsb', 123, True, '黑哥']s = "alex"
# 字符串是不可变数据s = "wusir" s[0] = "b"print(s)
列表的增,删,改,查
增加
| 方法 | 描述 | 代码 |
|---|---|---|
| append() | 在列表末尾追加 | lis.append(4) |
| insert() | 在列表指定位置插入值 | lis.insert(0,0) |
| extend() | 在列表末尾进行迭代添加 | lis.extend("456") |
lst = ["dsb",123,True,"黑哥"]lst.append("大煎饼")
# 追加(在列表的最后位置追加一个内容)print(lst)
# ["dsb",123,True,"黑哥","大煎饼"]lst.insert(2,"wusir")
# 插入 以后尽量不要使用(当数据量比较大的时候会影响效率)
print(lst)
# ["dsb",123,"wusir",True,"黑哥"]lst.extend("可迭代的内容")
#迭代添加print(lst) # ['dsb', 123, True, '黑哥', '可', '迭', '代', '的', '内', '容']
删除
| 方法 | 描述 | 代码 |
|---|---|---|
| pop() | 默认删除最后一个，可以通过下标指定删除 | lis.pop(1) |
| remove() | 通过元素的名字进行删除 | lis.remove(2) |
| del | 通过索引、切片、步长删除 | del lis[::2] |
| clear() | 清空列表 | lis.clear() |
lst = ["dsb",123,True,"黑哥"]lst.pop()
# 弹--默认删除最后一个print(lst)
# ['dsb', 123, True]lst.pop(2)
# 通过指定索引进行删除print(lst)
# ["dsb",123,"黑哥"]#通过pop删除,有返回值返回的是被删除的元素#lst = ["dsb",123,"dsb",True,"黑哥"]lst.remove("dsb")
# 移除 -- 通过元素名字进行删除print(lst)
# [123,"dsb",True,"黑哥"] del lst[0]
# 通过索引删除print(lst)
# [123,True,"黑哥"]del lst[0:3]
# 通过切片删除print(lst)
# ["黑哥"]del lst[0:3:2]
# 通过步长删除print(lst)
# [123, '黑哥']lst.clear()
# 清空print(lst)
# []
改
| 方法 | 描述 | 代码 |
|---|---|---|
| = | 通过索引、切片、步长进行修改 | lis[::2] = "2","2" |
lst = [123,"dsb",True,"黑哥"]lst[1] = "123"
# 通过索引改变print(lst)
# [123, '123', True, '黑哥']lst[1:2] = "12345"
# 通过切片改变,且此方法改变结果为迭代方式print(lst)
# [123, '1', '2', '3', '4', '5', True, '黑 哥'] lst[1:4] = 12,13,14,15 # 通过切片改变,但此方法不迭代print(lst)
# [123, 12, 13, 14, 15]# 切片改变列表,元素可以超出切片的位数lst[1:4:2] = "12"/1,2
# 通过步长改变,步长不为1的必须一一对应,多一个也不行,少一个也不行print(lst)
# [123, '1', True, '2']
查
| 方法 | 描述 | 代码 |
|---|---|---|
| for | 遍历查询 | for i in lst1: |
| lis[0:6:2] | 通过索引、切片、步长进行查找 | lis[0:6:2] |
for 循环lst = ["dsb",123,"dsb",True,"黑哥"]for i in lst: print(i) # dsb 123 dsb True 黑哥
列表的嵌套
lst = [1,"alex","春生","小东北","渣弟",["大黑哥",["常鑫",["自行车"],"大煎饼","掉井盖","三金"],"冯强","海峰",["太白金星","女神","吴超",["肖锋"]]]]用索引的方式找到"自行车"print(lst[-1][1][1][0])
# "自行车"a = lst[-1][-1][-2]print(a)
# 吴超# 不管什么类型,进行切片的时候获取到的都是原数据类型
# 取值通过索引进行取值,一层一层的进行查找
list
1.定义方式
lst = [1,"alex","春生","小东北","渣弟",["大黑哥",["常鑫",["自行车"],"大煎饼","掉井盖","三金"],"冯强","海峰",["太白金星","女神","吴超",["肖锋"]]]]用索引的方式找到"自行车"print(lst[-1][1][1][0])
# "自行车"a = lst[-1][-1][-2]print(a)
# 吴超# 不管什么类型,进行切片的时候获取到的都是原数据类型# 取值通过索引进行取值,一层一层的进行查找
2.其他方法
2.1 排序 (默认升序)
lst = [1,2,23,234,435,36,23,213421,421,4231,534,65]
lst.sort()
print(lst)lst = ["你好","我好"]
lst.sort()
print(lst)
2.2 反转
lst = [1,2,3,4453,5,6,7]print(lst[::-1])
lst.reverse()
print(lst)lst =[1,2,3,4,5123,21345,231123,4,1235,234,123]lst.sort()lst.reverse()print(lst)
面试题:
拼接两个列表方式一:
lst.extend(lst1)print(lst)
方式二:
print(lst+lst1)
正题
lst = [1,2,3,4,5]
lst1= lst
* 5new_lst = lst
* 5print(new_lst[0] is new_lst[-5])
# True扩展lst = [[]]new_lst = lst
* 5new_lst[0].append(10)print(new_lst)
# [[10], [10], [10], [10], [10]]lst = [1,[]]new_lst = lst
* 5new_lst[0] = 10print(new_lst)
# [10, [], 1, [], 1, [], 1, [], 1, []]lst = [1,[]]new_lst = lst * 5new_lst[1] = 10print(new_lst)
# [1, 10, 1, [], 1, [], 1, [], 1, []]lst = [[]]new_lst = lst
* 5new_lst[0].append(10)print(new_lst)
# [[10], [10], [10], [10], [10]]
元组
定义
元组 -- tuple
有序,不可变,支持索引
只能索引查看和for查看,不能进行增删改
元组用于存储一些比较重要的信息
元组在配置文件中会使用
元组就是不可变的列表
定义一个元组:
tu = (1,"alex",True,"大黑哥",[1,2,3])l
st = [1,"alex",True,"大黑哥",[1,2,3]]print(tu)
# (1, 'alex', True, '大黑哥', [1, 2, 3])
tu = (1,"alex",True,"大黑哥",[1,2,3])
print(tu[0:6])
# (1, 'alex', True, '大黑哥', [1, 2, 3])
for 循环
for i in tu:
print(i)
# 1 alex True 大黑哥 [1, 2, 3]
tuple
tu = ("12")
# 数据类型是( )中数据本身print(type(tu))# <class 'str'>tu = (1,)
# (1,) 是元组print(type(tu))
# <class 'tuple'>元组 加 乘 不可变共用,可变也共用
range
定义
range -- 范围
print(list(range(0,10))) # 顾头不顾尾
python2 和 python3 中的区别
Python3 中的 range 是一个可迭代对象,写的是怎样打印的时候就是怎样
Python2 中的 range 返回的是一个列表
range的使用
print(list(range(0,10,1)))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 步长不写得时候默认为1 [0:10:1]print(list(range(10,-2,-1)))
# [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1]
# 步长不写得时候默认为1 [10:-2:-1]print(list(range(10))) # 步长不写得时候默认为1 [:10]
使用for循环和range
打印
100 - 1for i in range (100,0,-1):
print(i)
打印 1 - 100的所有奇数
for i in range(1,101,2):
print(i) 打印
1 - 100的所有偶数
for i in range(2,101,2):
print(i)
打印 1 - 100的所有被6整除的数
for i in range(6,101,6):
print(i)
让用户输入姓名,并在第三次输入后停止输入,打印出所有输入的名字.使用
while 循环
lst = []flage = Truewhile flage:
name = input("请输姓名:")
# 请输姓名:agag lst.append(name)
# 请输姓名:garag if len(lst) == 3:
# 请输姓名:garg flage = False
# ['agag', 'garag', 'garg']print(lst) 使用 for 循环和rangelst = []for i in range(3): lst.append(input("请输入姓名:"))print(lst)
# 请输入姓名:sssht
# 请输入姓名:shtst
# 请输入姓名:hst
# ['sssht', 'shtst', 'hst']
字典
定义
字典 -- dict
字典是无序的,可变的数据类型
字典:用于存储数据,存储大量数据,字典要比列表快,将数据和数据之间进行关联
定义一个字典:
dic = {"常鑫":10,"李文虎":80,"张宇":100}字典中逗号分隔叫做一个元素"常鑫"(键):10(值) -- 键值对dic = {"常鑫":10,"李文虎":80,"张宇":100,10:"大黑哥",True:123,(1,2,3):"大煎饼",[1,2]:"meet"}print(dic)
#报错 列表字典集合可变不能为"键"
字典的键:
可哈希的 --- 不可变的数据类型 --- 避免哈希冲突使用了 开放寻址法
不可哈希的 --- 可变的数据类型
要求唯一 --- 如果有重复的后边值的将前面的值覆盖
字典的值:
可以任意
字典的增,删,改,查
增:
| 方法 | 描述 | 代码 |
|---|---|---|
| 强制添加 | 如果所添加的键已存在字典中则会将其的值替换 | dic["1"] = 1 |
1.dic = {"常鑫":10,"李文虎":80,"张宇":100}dic["李文虎"] = 89
print(dic)
# dic = {"常鑫":10,"李文虎":89,"张宇":100}
# 暴力添加 2.dic = {"常鑫":10,"李文虎":80,"张宇":100}dic.setdefault("大黑哥",50) print(dic)
# {'常鑫': 10, '李文虎': 80, '张宇': 100, '大黑哥': 50}
# "大黑哥"这个键去字典查询,没有就添加,有就不执行添加.
删除:
| 方法 | 描述 | 代码 |
|---|---|---|
| del | 删除指定键的值，如果未指定键则会删除整个字典 | del dic["1"] |
| pop() | 删除指定键的值 | dic.pop("1") |
| clear() | 清空字典 | dic.clear() |
| popitem() | 随机删除返回被删除键值对(python3.6默认删除最后一个) |
1.dic = {"常鑫":10,"李文虎":80,"张宇":100}del dic["常鑫"]prin(dic)
# {'李文虎': 80, '张宇': 100}# 通过字典的键删除键值对
2.dic = {"常鑫":10,"李文虎":80,"张宇":100}print(dic.pop("常鑫"))
# 10print(dic)
# {'李文虎': 80, '张宇': 100}
# 通过字典的键进行删除键值对 返回值:返回的是删除的值
3.dic = {"常鑫":10,"李文虎":80,"张宇":100}
dic.clear()
print(dic)
#{}# 清空
改:
| 方法 | 描述 | 代码 |
|---|---|---|
| 强制修改 | 如果所添加的键已存在字典中则会将其的值替换 | dic["1"] = 1 |
| update() | 将指定字典更新入远的字典，如果指定字典的键与原字典相同则替换值，如果不同则进行添加 | dic.update(dic2) |
1.dic = {"常鑫":10,"李文虎":80,"张宇":100}
dic["常鑫"] = "dsb"print(dic)
# {'常鑫': 'dsb', '李文虎': 80, '张宇': 100}
# 字典中没有某个键值对的时候就是添加,当键在字典中存在的时候就是修改
# 有则改,无则加
2.dic = {"常鑫":10,"李文虎":80,"张宇":100}
dic.update({"常鑫":50,"张宇":30})print(dic)
# {'常鑫': 50, '李文虎': 80, '张宇': 30}
# update括号中的字典级别高于update前面的字典
查:
| 方法 | 描述 | 代码 |
|---|---|---|
| for | 通过for遍历字典的键 | for i in dic: |
| get() | 使用键查询对应的值，如果存在返回值，否则返回None，可以指定返回值 | dic.get("1"，1) |
| 键查询 | 通过键查询其值，如果存在返回值，否则会提示错误 | dic["1"] |
| setdefaule() | 如果查询的键存在返回对应的值，键不存在时进行添加，值为设置的默认值。 | a.setdefault(3,"222") |
1.dic = {"常鑫":10,"李文虎":80,"张宇":100}for i in dic: print(i)
# 常鑫
# 李文虎 # 张宇#循环获取的是字典中每个键值对的键
2.dic = {"常鑫":10,"李文虎":80,"张宇":100}print(dic.get("李文虎"))
# 80# 通过键获取值,如果将不存在字典中返回Noneprint(dic["ck"])
# 报错# 通过键获取值,如果将不存在字典中报错
其他操作
| 方法 | 描述 | 代码 |
|---|---|---|
| keys() | 将字典中所有的键存放在一个高仿列表中 | dic.keys() |
| values() | 将字典中所有的值存放在一个高仿列表中 | dic.values() |
| items() | 将字典中的所有的键和值以元组的形式存放在一个高仿列表中 | dic.items() |
1.dic = {"1":3,"5":9,"李文虎":100}
for i in dic:
print(i,dic.get(i))
# 1 3# 5 9# 李文虎 100
# 获取字典中所有的键和值
2.dic = {"1":3,"5":9,"李文虎":100}print(dic.keys())
# dict_keys(['1', '5', '李文虎'])
# 高仿列表 -- dict_keys(['1', '5', '李文虎']) 支持for循环 不支持索引
3.dic = {"1":3,"5":9,"李文虎":100}
for i in dic.keys():
print(i) # 1 # 5 # 李文虎# 获取字典中所有的键
4.dic = {"1":3,"5":9,"李文虎":100}
lst = []for i in dic:
lst.append(dic[i])print(lst)
#[3, 9, 100]# 获取字典中所有的值
5.print(list(dic.values()))
#[3, 9, 100]# 获取字典中所有的值
6.dic = {"1":3,"5":9,"李文虎":100}
print(dic.items())
# dict_items([('1', 3), ('5', 9), ('李文虎', 100)])
7.dic = {"1":3,"5":9,"李文虎":100}
for i in dic.items():
print(i[0],i[1])
# 1 3 # 5 9 # 李文虎 100
随机删除:
dic = {"key":1,"key2":2,"key3":56}
print(dic.popitem())
# 返回的是被删除的键值对(键,值)print(dic)# python3.6 默认删除最后一个(bug)
批量添加:
dic = {}dic.fromkeys("123",[23])
# 批量添加键值对{"1":[23],"2":[23],"3":[23]}print(dic)dic = dict.fromkeys("123456789",1)\
# 批量添加键值对"键是可迭代对象",值 -- 会被共用dic["1"] = 18print(dic)
解构
a,b = 10,12
print(a)
print(b) # 10 # 12
a = 10b = 20a,b = b,aprint(a,b)
# 20 10
a,b = [1,2]print(a,b)
# 1 2a,b = (3,4)print(a,b)
# 3 4a,_,b = (3,4,5)print(a,b)
# 3 5 等号后边的值和前面的变量名要一一对应a = 10,12
print(a)
# (10,12) 本质就是一个元组
a,b = "23"print(a,b)
# 2 3a,b = {"1":"a","2":"b"}print(a,b)
# 1 2 dic = {"1":3,"5":9,"李文虎":100}
for i in dic.items():
print(i)
# ('1', 3) # ('5', 9) # ('李文虎', 100)
dic = {"1":3,"5":9,"李文虎":100}for k,v in dic.items():
print(k,v)
# 1 3 # 5 9 # 李文虎 100 # 获取每个元素的键和值
集合 -- set
set() -- 空集合{} -- 空字典定义集合:set("alex") # 迭代添加的
定义集合:
没有值的字典
无序 -- 不支持索引
天然去重
s = {1,"alex",False,(1,2,3),12,1,12,4,6,32,2,4}print(s)
面试题:
lst = [1,2,1,2,4,2,45,3,2,45,2345,]
print(list(set(lst)))s = {1,2,3,4}
集合的增删改查:
1.增:
| 方法 | 描述 | 代码 |
|---|---|---|
| add() | 添加一个值 | se.add(1) |
| update() | 迭代添加 | se.update("abc") |
增:s.add("67")
# 只能添加一个print(s)s.update("今天")
# 迭代添加print(s)
2.删
| 方法 | 描述 | 代码 |
|---|---|---|
| pop() | 随机删除，返回的是被删除的值 | se.pop() |
| remove() | 指定值删除 | se.remove(2) |
| clear() | 清空集合 | se.clear() |
print(s.pop())
# pop有返回值print(s)s.remove(3)
# 指定元素删除print(s)s.clear()
# 清空 -- set() 空集合print(s)
3.改
先删再加
4.查
| 方法 | 描述 | 代码 |
|---|---|---|
| for | 通过for循环遍历集合 | for i in se: |
for i in {1,2,3}: print(i)
其他操作:
| 方法 | 描述 | 代码 |
|---|---|---|
| & | 交集 | se1&se2 |
| | | 并集 | se1|se2 |
| - | 差集 | se1-se2 |
| ^ | 反交集 | se1^se2 |
| > | 父集 | se1>se2 |
| < | 子集 | se1<se2 |
| frozenset() | 冻结集合 | frozenset(se) |
s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,1}print(s1 & s2)
# 交集 {1, 5, 6, 7}print(s1 | s2)
# 并集 {1, 2, 3, 4, 5, 6, 7}print(s1 - s2)
# 差集 {2, 3, 4}print(s1 ^ s2)
# 反交集 {2, 3, 4}print(s1 > s2)
# 父集(超集) Trueprint(s1 < s2)
# 子集 Falseprint(frozenset(s1))
# 冻结集合 更不常用
frozenset({1,2,3,4,5,6,7})
dic = {frozenset(s1):1}print(dic)
#{frozenset({1, 2, 3, 4, 5, 6, 7}): 1}
数据类型之间转换
list tupletuple liststr转
list的方法:name = "alex"
print(name.split())
list转 str的方法:
lst = ["1","2","3"]
print(''.join(lst)
数据类型总结
| 分类 | 数据类型 |
|---|---|
| 可变 | list,dict,set |
| 不可变 | int,str,tuple,bool |
| 有序 | list,tuple,str,int,bool |
| 无序 | dict,set |
| 取值方式 | |
| 索引 | str,list,tuple |
| 直接 | set,int,bool |
| 键 | dict |
python的数据类型
可变:list ,dict ,set
不可变:int bool str tuple
有序:list,tuple,str,int,bool
无序:dict,set取值方式:
索引: str list tuple
直接: set ,int ,bool
键: dict
以后会遇见的坑
for的死循环
lst = [1,2]for i in lst:
lst.append(3)print(lst)# 打印不出内容
删除列表的坑
lst = [1,2,3,4]
for i in lst:
lst.pop()
print(lst)
# [1, 2]
lst = [1,2,3,4]
for i in lst:
lst.pop(0)print(lst)
# [3, 4]
lst = [1,2,3,4]
for i in lst:
lst.remove(i)
print(lst)# [2, 4]
成功删除的方式
lst = [1,2,3,4,5]
for i in range(len(lst)):
lst.pop()print(lst)
lst = [1,2,3,4,5]
for i in range(len(lst)-1,-1,-1):
del lst[i]print(lst)
lst = [1,2,3,4,5]
for i in range(len(lst)):
del lst[-1]
print(lst)
lst = [1,2,3,4,5]
lst1 = lst.copy()
for i in lst1:
lst.remove(i)print(lst)
删除字典的坑
dic = dict.fromkeys("12345",1)
for i in dic:
dic.pop(i)
print(dic)# 报错# 字典的迭代的时候改变了原来的大小(不能加不能删)
正确删除的方式
dic = dict.fromkeys("12345",1)
dic1 = dic.copy()
for i in dic1:
dic.pop(i)print(dic)
# {}# 集合和字典都是迭代的时候不能改变原来的大小
二次编码
密码本:
ascii -- 没有中文
gbk -- 英文 8b(位) 1B(字节) 中文 16b 2B
unicode -- 英文16b 2B 中文32b 4B
utf-8 -- 英文8b 1B 欧洲16b 2B 亚洲24b 3B
name = "你好啊"s1 = name.encode("utf-8")
# 编码 s2 = name.encode("gbk")
# 编码 s2 = s1.decode("utf-8")
# 解码print(s2.encode("gbk"))
小数据池 -- 缓存机制(驻留机制)
== 判断两边内容是否相等
a = 10b = 10print(a == b)
is 是
a = 10b = 10print(a is b) is判断基于内存地址进行判断
代码块:
一个文件,一个函数,一个类,一个模块,终端中每一个行是一个代码块
数字:
在同一代码块下 只要内容相同就采用相同的内存地址(-5以后就不是)
数字在做乘法的时候范围 -5 ~ 256
数字在做乘法的时候不能使用浮点数
字符串:
在同一代码块下 只要内容相同就采用相同的内存地址
乘法的时候总长度不能超过20
乘法的时候中文,特殊符号乘以1或0
布尔值:
在同一代码块下 只要内容相同就采用相同的内存地址
小数据池:
数字:
-5 ~ 256
字符串:
在同一代码块下 只要内容相同就采用相同的内存地址
乘法的时候总长度不能超过20
乘法的时候中文,特殊符号乘以0
布尔值:
在同一代码块下 只要内容相同就采用相同的内存地址
小数据池的验证方法,必须脱离代码块才能进行验证
先执行代码块的规则,在执行小数据的规则 --(驻留机制)
必会:
== 判断等号两边的值是否相等
is 判断两边的内存地址是否相等
深浅拷贝 (复制)
面试必问 : 赋值,浅拷贝,深拷贝
赋值
lst = [1,2,3,[5,6,7]]lst1 = lstprint(lst1)
#[1, 2, 3, [5, 6, 7]]print(lst)
#[1, 2, 3, [5, 6, 7]]lst[-1].append(8)print(lst1)
#[1, 2, 3, [5, 6, 7, 8]]print(lst)
#[1, 2, 3, [5, 6, 7, 8]]
浅拷贝
lst = [1,2,3,[5,6,7]]lst1 = lst.copy()
# 新开辟一个空间给lst1print(lst[-1])
# [5, 6, 7]print(lst1[-1])
# [5, 6, 7]浅拷贝的时候,只会开辟一个新的容器列表,其他元素使用的都是源列表中的元素
lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()
lst1[-1].append(8)print(lst)
#[1, 2, 3, [5, 6, 7, 8]]
print(lst1)
#[1, 2, 3, [5, 6, 7, 8]]
lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()
lst[3] = 567print(lst1)
#[1, 2, 3, [5, 6, 7]]
print(lst)
#[1, 2, 3, 567]
lst = [1,2,3,4,[5,6,7,[8,9]]]
lst1 = lst.copy()
lst1.append(10)
print(lst)
#[1,2,3,4,[5,6,7,[8, 9]]]
print(lst1)
#[1,2,3,4,[5,6,7,[8,9]],10]
lst = [1,2,3,4,[5,6,7,[8,9]]]
lst1 = lst.copy()
lst1[-1][-1] = "56"print(lst)
#[1,2,3,4,[5,6,7,'56']]
print(lst1)
#[1,2,3,4,[5,6,7,'56']]
lst = [[1,2,],90,6,7,[5,6]]
lst1 = lst.copy()lst1[-1] = 8print(lst)
#[[1, 2], 90, 6, 7, [5, 6]]print(lst1)
#[[1, 2], 90, 6, 7, 8]
dic = {"alex":[1,2,3,[5,6]]}
dic1 = dic.copy()dic["alex"][0] = "56"print(dic)
#{'alex': ['56', 2, 3, [5, 6]]}print(dic1)
#{'alex': ['56', 2, 3, [5, 6]]}
深拷贝
import copy
# 导入lst = [1,2,3,[5,6,7]]lst1 = copy.deepcopy(lst)
# 深拷贝lst[-1].append(8)print(lst)
# [1, 2, 3, [5, 6, 7, 8]]print(lst1)
# [1, 2, 3, [5, 6, 7]]
lst = [1,2,3,[5,6,7,[8,10,9]]]
import copylst1 = copy.deepcopy(lst)lst[-1][-1][1] = 5print(lst)
# [1, 2, 3, [5, 6, 7, [8, 5, 9]]]
print(lst1)
# [1, 2, 3, [5, 6, 7, [8, 10, 9]]]
总结:
浅拷贝的时候只拷贝第一层元素
浅拷贝在修改第一层元素(不可变数据类型)的时候,拷贝出来的新列表不进行改变
浅拷贝在替换第一层元素(可变数据类型)的时候,拷贝出来的新列表不进行改变
浅拷贝在修改第一层元素中的元素(第二层)的时候,拷贝出来的新列表进行改变
深拷贝开辟一个容器空间(列表),不可变数据共用,可变数据数据类型(再次开辟一个新的空间),空间里的值是不可变的数据进行共用的,可变的数据类型再次开辟空间
文件操作
创建文件"asdf.txt"
open( )
# 打开file
# 文件的位置(路径)mode
# 操作文件的模式encoding
# 文件编码方式f
# 文件句柄f = open("文件的路径(文件放的位置)",mode="操作文件的模式",encoding="文件的编码")
# 内置函数f(文件句柄)f = open("asdf",mode="r",encoding="utf-8")print(f.read())f.close()
路径:
1.绝对路径 -- C:\user\meet\python24\asdf 2.相对路径
绝对路径方式打开文件 f = open("F:\s24\day08\asdf","r",encoding="utf-8") print(f.read())
相对路径方式打开文件 f = open("../day03/asdf","r",encoding="utf-8") print(f.read()) ../ 返回上一层
f = open(r"C:\user\net\s24\day03\asdf","r",encoding="utf-8")
路径转义: 1."" 2.r"C:\user\net" 推荐使用相对路径 (*****)
s = "[1,'2',3,4]" print(s) print(repr(s)) # repr -- 显示数据原生态 ```
文件操作的模式:
| 文件打开模式 | 描述 |
|---|---|
| r | 以只读模式打开文件，并将文件指针指向文件头；如果文件不存在会报错 |
| w | 以只写模式打开文件，并将文件指针指向文件头；如果文件存在则将其内容清空，如果文件不存在则创建 |
| a | 以只追加可写模式打开文件，并将文件指针指向文件尾部；如果文件不存在则创建 |
| r+ | 在r的基础上增加了可写功能 |
| w+ | 在w的基础上增加了可读功能 |
| a+ | 在a的基础上增加了可读功能 |
| b | 读写二进制文件（默认是t，表示文本），需要与上面几种模式搭配使用，如ab，wb, ab, ab+（POSIX系统，包括Linux都会忽略该字符） |
r,w,a (********)
r: 读文本
| 方法 | 描述 | 代码 |
|---|---|---|
| read() | 读取全部内容 | f.read() |
| read(5) | 按照字符读取 | f.read(5) |
| readline() | 按照行进行读取(自动换行) | f.readline() |
| readlines() | 按照行进行读取，存放在列表中 | f.readlines() |
| for | 使用for循环可以解决大文件读取 | for i in f: |
r操作:
f = open("asdf",mode="r",encoding="utf-8")print(f.read())
#全部读取print(f.read(5))
#按照字符进行读取print(f.read())print(f.readline())
# 读取一行内容,自动换行print(f.readline())
# "常鑫你就是大帅比\n"print(f.readline().strip())
#去除换行符print(f.readlines())
# 一行一行的读取,存放在列表中
解决大文件:
for i in f:
print(i)
# 本质就是一行一行进行读取
print(f.readline())
print(f.readline())
print(f.readline())
w:清空,写
| 方法 | 描述 | 代码 |
|---|---|---|
| write() | 写入文件 | f.write("123") |
w分为两步:
1.先清空文件
2.写入文件
open("xxx","w",encoding="utf-8")
# 进行清空
write()
只能写字符串
a:追加在源文件的基础上进行添加
f = open("../day03/asdf","a",encoding="utf-8")
f.write("138383848\n")f.write("138383850\n")
w,a 检测有文件就操作,没文件就创建
rb,wb,ab(****)
rb:读字节
| 方法 | 描述 | 代码 |
|---|---|---|
| read() | 全部读取 | f.read() |
| read(5) | 按字节读取 | f.read(5) |
read() 全部读取
read(3) 看文件的前三字节
readline 读取一行(自带换行符)
readlines() 一行一行读取存放在列表中wb:清空,写
| 方法 | 描述 |
|---|---|
| write() | 先清空在写入，只能写字节 |
open("xxx","wb") # 进行清空
write() 只能写字节ab:追加
open("xxx","ab")
write() 只能写字节
r+,w+,a+ (r+**)
r+:读写 错误的方式是写读 先读后写
在r+模式下. 如果读取了内容. 不论读取内容多少. 光标显示的是多少. 再写入 或者操作文件的时候都是在结尾进行的操作.w+:清空写,读
1.清空文件 写入
2.读取内容(默认读取的是空)a+:追加写,读
1.先写后读
2.读取内容(默认读取的是空)
# 注意点: (a,ab,a+)将光标移动到某个位置进行,写入的时候还是在文件的末尾
其他操作:
光标
| 方法 | 描述 | 代码 |
|---|---|---|
| tell() | 查看光标，返回的是字节 | f.tell() |
| seek(3) | 移动光标(根据编码按字节计算) | f.seek() |
| seek(0,0) | 移动到文件头部 | f.seek(0,0) |
| seek(0,1) | 当前位置 | f.seek(0,1) |
| seek(0,2) | 移动文件末尾 | f.seek(0,2) |
文件修改:
修改文件内容:
1.创建一个新的文件
2.将文件中的内容进行替换
3.替换后的内容写入新文件中
4.改变文件名
示例:
with open("asdf","r",encoding="gbk")as f,\
open("asdf.txt","w",encoding="gbk")as f1:
for i in f:
s1 = i.replace("大烧饼","井盖")
f1.write(s1)
import os
os.rename("asdf","asdf.bak")
os.rename("asdf.txt","asdf")
with as
with 关键字 open("xxxx","r",encoding="gbk") as f:
文件操作的具体内容
with open("文件路径","操作模式",编码")as f:
操作文件
with open的好处:
1.可以同时打开多个文件
2.能够自动关闭文件
f = open("文件的路径(文件放的位置)",mode="操作文件的模式",encoding="文件的编码") # 内置函数
f(文件句柄)
浙公网安备 33010602011771号