一、python简介
- python是由荷兰人Guido van Rossum于1989发明，第一个公开发行版本于1991年。python是一门解释型语言，开发效率高，但是运行速度相对较慢。
- python是弱类型语言，具有简洁，优雅，清晰的特点。
- python的应用领域：科学计算、人工智能、网络爬虫、图形界面、web开发等。
- python安装
安装和环境配置教程：https://jingyan.baidu.com/article/c45ad29c05c208051653e270.html
- python之变量
命名规则：
1.必须使用英文字母，数字，下划线组成
2.不能使用数字作为开头，更不能是纯数字
3.禁止使用关键字作为变量名
4.不要太长
5.区分大小写
6.不要使用中文作为变量名
7.要有意义
8.推荐使用驼峰和下划线变量名
二、数据类型
- int （整型）可做加，减，乘，除，取余，取整运算（+，-，*，/，%，//） 主要用来进行数学运算
- str （字符型） 字符拼接（+） 重复（*） ； " ",' ',''' ''',""" """ 都是字符串 存储少量的数据
- bool(布尔型) True为真，False为假 用于判断真假 True, False
- dict (字典） 一对一对的存储数据. key:value {" ":" "," ":" "}
- list （列表） 存取大量数据
- tuple（元组） 只读列表, 不能改( )
- set （集合） 存储不重复的内容
查看数据类型
a=2
print(type(a))
>>> int
数据运算
a=1 b=2 c=a+b print(c)
>>> 3
字符串拼接
s1 = "sylar" s2 = "wusir" s3 = "alex" s4 = s1 + s2 + s3 # 字符串拼接(连接) print(s4)
>>> "sylarwusiralex"
重复
s = "考试 " print(s*3) # s 重复 3次
>>> 考试
考试
考试
三、运算符
- 运算可分为:算数运算,比较运算,逻辑运算,赋值运算,成员运算,身份运算,位运算.
- 算数运算
- 运算符: '+' , '-' ,'*' , '/' , '%' ,'//' , '**' ( 依次为 加 减 乘 除 取余 取整 次幂)
- 比较运算
- 运算符: '==' , '!=' , '<>' , '>' , '<' , '>=' , '<=' (依次为 等于 不等于 不等于 大于 小于 大于等于 小于等于)
- 赋值运算
- 运算符: '=' , '+=' , '-=' , '*=' , '/=' , '**=' , '//=' , '%='
- 逻辑运算:
- 运算符: 'and' , 'or' , 'not'
- and: 并且的意思. 左右两端的值必须都是真. 运算结果才是真
- or: 或者的意思. 左右两端有一个是真的. 结果就是真. 全部是假. 结果才能是假
- not: 非的意思. 原来是假. 现在是真. 非真即假, 非假既真
- 算数运算
逻辑运算优先级: () > not > and > or
判断下列列逻辑语句句的True，False.
3>4 or 4<3 and 1==1
1 < 2 and 3 < 4 or 1>2
2 > 1 and 3 < 4 or 4 > 5 and 2 < 1
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8
1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6
not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6
>>>>运算结果依次为:False , True , True , False , False , False
第二种运算方法:
x or y , x为真，值就是x，x为假，值是y
x and y, x为真，值是y,x为假，值是x
判断下列逻辑语句
print(0 or 1 or 3 or 0 or 5)
print(1 and 2)
print(2 and 0)
print(0 and 3)
print(0 and 4)
print(0 or 4 and 3 or 7 or 9 and 6)
print(2 > 3 and 3)
print(2 < 1 and 4 > 6 or 3 and 4 > 5 or 6)
>>>>>>>运算结果依次为: 1 , 2 , 0 , 0 , 0 , 3 , 0 , 6
四、if条件判断、while循环、for循环
-
while循环
基本用法:
while 条件:
代码块1
else:
代码块2
运行流程:1)当条件成立时,执行代码块1
2)再次判断条件是否为真,如果为真,再次执行代码块1.......
3)当条件为假.执行else 跳出循环. 循环结束
1.使用while循环输出1-10的整数
i=1 while i<=10: print(i)
2.输出1-100所有整数的和
i=1 sum =0 while i<=100: sum=sum+i i+=1 print(i)
3.输出1-100内的所有奇数
num = 1 while num <= 100: if num % 2 != 0: print(num) num += 1
4.猜数字小游戏
count = 3 num =66 while count >= 1: guess = input("请输入一个数字:") if guess == num: print("猜测结果正确") break elif guess > num: print("猜测结果大了") else: print("猜测结果小了") count -= 1 else: print("太笨了你.....")
5.求1-2+3-4+5....99的所有数的和.
1 start = 1 2 sum = 0 3 while start <100: 4 temp = start % 2 5 if temp ==1: 6 sum = sum + start 7 else: 8 sum = sum - start 9 start += 1 10 print(sum)
6.输入一个数,判断这个数是几位数(用算法实现)
1 1 count = 1 2 2 num = int(input("请输入一个数字:")) 3 3 while True: 4 4 num = num / 10 5 5 if num < 10: 6 6 break 7 7 8 8 count += 2 9 9 print(count)
-
格式化输出
-
%s: 字符串的占位符, 可以放置任何内容(数字)
-
%d: 数字的占位符
-
1.字符串占位符示例
1 name = input("请输入名字:") 2 age = input("请输入你的年龄:") 3 hobby = input("输入你的爱好:") 4 gender = input("请输入你的性别:") 5 6 print("%s今年%s岁, 是一个老头, 爱好是%s, 性别:%s" % (name, age, hobby, gender))
2.数字占位符示例
a = 108 s = "梁山水泊有%d个厉害的人物" % (a) print(s)
>>>>小提示:如果字符串中有了占位符. 那么后面的所有的%都是占位. 需要转义;如果这句话中没有占位符. %还是%
break 结束循环. 停止当前本层循环
continue 结束当前本次循环. 继续执行下一次循环
-
用户交互（input）
变量 = input（"提示语："） 变量是字符串类型 ，字符串=> 数字 => int(str)
count = input("请输入你要玩的次数：")
print(count)
>>>请输入你要玩的次数：3
>>> 3
#程序执行，未输入数字时，程序为阻塞状态
-
if判断语句
if语句基本用法
if 条件判断：
代码块
运行流程：当条件成立，执行代码块
if 条件1:
代码块1
elif 条件2:
代码块2
else:
代码块n
运行流程：当条件1成立，执行代码块1；如果条件1不成立，条件2成立，则执行代码块2；如果所有条件都不成立，则执行代码块n
1.用户登录
user=input("enter your username:") password=input("enter your password:") if user=="liqing" and password=="123456": print("登录成功") else: print("用户名或密码错误")
>>>>>>>>> 如果输入的user为"liqing",并且password为"123456",则会打印登录成功，否则打印用户名或密码错误。
2.猜年龄
import random age=random.randint(1,10) guess=int(input("enter number(1-10):")) if guess==age: print("恭喜你猜对了t") else： print("对不起，你猜错了")
>>>>>>>>>>>import random #导入内置函数 random为随机数函数
>>>>>>>>>>>age=random.randint(1,10) #随机生成一个1到10的整数，并赋值给age
>>>>>>>>>>>输入一个数字（范围1-10），如果输入的数字与生成的随机数相同，打印恭喜你猜对了，否则打印对不起，你猜错了。
-
迭代
for 变量 in 可迭代对象:
循环体
else:
1 s19 = "大家好, 我是VUE, 前端的小朋友们. 你们好么?" 2 3 # 用while循环 4 5 index = 0 6 while index < len(s19): 7 print(s19[index]) # 利用索引切片来完成字符的查找 8 index = index + 1 9 10 # for循环, 把s19中的每一个字符拿出来赋值给前面的c 11 12 for c in s19: 13 print(c)
-
range
range介绍:
作用:数数
有一个参数:结束为止
两个参数: 1. 起始位置, 2.结束位置
三个参数: 1. 起始位置, 2. 结束位置. 3.步长
range基本应用:
1 #range() 应用: 2 for i in range(10): # 从0开始. 到10结束 3 print(i) 4 5 for i in range(3, 7): # 从3 开始. 打印到7结束. 不能到7 6 print(i) 7 8 for i in range(3, 10, 2): # 从3 到 10 每2个取一个 9 print(i) 10 11 for i in range(10, -10, -1): #从10 开始到-10结束. 倒着数 12 print(i)
计算:
1 # 求1-2+3-4...+99-100=? 2 sum = 0 3 for i in range(1, 101): 4 if i % 2 == 0: 5 sum = sum - i 6 else: 7 sum = sum + i 8 print(sum)
五、字符串、列表、元组、字典、集合操作
-
int bool str 概述
int 方法操作:
bit_length() 求二进制长度
bool: 类型转换
1. 你想转换成什么. 就用什么把目标包裹起来
2. 带空的是False, 不带空的True
str：str索引和切片
索引：起始下标是0(从左到右), (-1)从右到左
1 s1 = "python⽜B" 2 print(s1[0]) # 获取第0个 3 print(s1[1]) 4 print(s1[2]) 5 print(s1[3]) 6 print(s1[4]) 7 print(s1[5]) 8 print(s1[6]) 9 print(s1[7]) 10 print(s1[8]) # 11 print(s1[9]) # 没有9, 越界了了. 会报错 print(s1[-1]) # -1 表示倒数. print(s1[-2]) # 倒数第二个
- 切片: s[起始位置: 结束位置: 步长] 步长: 如果是整数, 则从左往右取. 如果是负数. 则从右往左取. 默认是1
- 特点:顾头不顾尾
1 s2 = "python⽜牛B" 2 print(s2[0:3]) # 从0获取到3. 不包含3. 结果: pyt 3 print(s2[6:8]) # 结果 ⽜ 4 print(s2[6:9]) # 大是8. 但根据顾头不顾腚, 想要取到8必须给9 5 print(s2[6:10]) # 如果右边已经过了大值. 相当于获取到后 6 print(s2[4:]) # 如果想获取到后. 那么后⼀个值可以不给. 7 print(s2[-1:-5]) # 从-1 获取到 -5 这样是获取不到任何结果的. 从-1向右数. 你怎么数 也数不到-5 8 print(s2[-5:-1]) # ⽜b, 取到数据了了. 但是. 顾头不顾腚. 怎么取后⼀个呢? print(s2[-5:]) # 什么都不写就是后了 9 print(s2[:-1]) # 这个是取到倒数第⼀个 10 print(s2[:]) # 原样输出
-
字符串的常用操作: 常用方法
原字符串不可变.
-
- upper() 转换成大写
1 # 应用, 校验用户输入的验证码是否合法 2 verify_code = "abDe" 3 user_verify_code = input("请输⼊入验证码:") 4 if verify_code.upper() == user_verify_code.upper(): 5 print("验证成功") 6 else: 7 print("验证失败")
-
- strip() 去掉空格
1 # 应用, 模拟用户登录. 忽略用户输入的空格 2 username = input("请输入用户名:").strip() 3 password = input("请输入密码: ").strip() 4 if username == 'alex' and password == '123': 5 print("登录成功") 6 else: 7 print("登录失败")
-
- replace() 替换
1 # 字符串替换 2 s8 = "sylar_alex_taibai_wusir_eggon" 3 ret = s8.replace('alex', '金角⼤王') # 把alex替换成金角大王 4 print(ret) # sylar_金角⼤大王_taibai_wusir_eggon
-
- split() 切割
1 # 字符串切割 2 s9 = "alex,wusir,sylar,taibai,eggon" 3 lst = s9.split(",") # 字符串切割, 根据,进行切割 4 print(lst)
-
- format() 格式化输出
# 格式化输出 s12 = "我叫%s, 今年%d岁了, 我喜欢%s" % ('sylar', 18, '周杰伦') # 之前的写法 print(s12) s12 = "我叫{}, 今年{}岁了, 我喜欢{}".format("周杰伦", 28, "周润发") # 按位置格式化 print(s12) s12 = "我叫{0}, 今年{2}岁了, 我喜欢{1}".format("周杰伦", "周润发", 28) # 指定位置 print(s12) s12 = "我叫{name}, 今年{age}岁了, 我喜欢{singer}".format(name="周杰伦", singer="周润发", age=28) # 指定关键字 print(s12)
-
- startswith() 判断是否以xxx开头
1 s13 = "我叫sylar, 我喜欢python, java, c等编程语言." 2 ret1 = s13.startswith("sylar") # 判断是否以sylar开头 3 print(ret1) 4 ret2 = s13.startswith("我叫sylar") # 判断是否以我叫sylar开头 5 print(ret2)
-
- find() 查找. 找不到返回-1
1 ret5 = s13.find("sylar") # 查找'sylar'出现的位置 2 print(ret5) 3 ret6 = s13.find("tory") # 查找'tory'的位置, 如果没有返回-1 4 print(ret6) 5 ret7 = s13.find("a", 8, 22) # 切片找 6 print(ret7)
-
- len() 内置函数. 直接使用. 不用点操作 求字符串的长度
s18 = "我是你的眼, 我也是a" ret = len(s18) # 计算字符串的长度 print(ret)
-
基础数据类型补充
str.join() : 把列表变成字符串，遍历列表，依次把str插入到遍历的列表值末尾中，组成一个新的字符串
1 b = "&" 2 c = b.join(['gailun', 'zhaoxin', 'huangzi', 'manzi', 'jiansheng']) 3 print(c)
>>>>>>>>> gailun&zhaoxin&huangzi&manzi&jiansheng
列表在循环的时候不能被删除，因为索引会被改变
1 lst = ['that girl', 'firs', 'smile of her', 'my dream'] 2 for i in lst: 3 lst.remove(i) 4 print(lst)
>>>>>>>>>['firs', 'my dream']
结果显示列表并没有被删除干净，是因为列表循环时，指针会第一个指向索引为0的元素，当索引为0的元素被删除后，索引为1的元素会自动向前进一步，索引变成0，而指针再次寻找时，会指向索引为1的元素，所以原先索引为1的元素会被漏掉，从而导致列表删不干净
1 lst = ['that girl', 'firs', 'smile of her', 'my dream'] 2 lst1 = [] 3 for i in lst: 4 lst1.append(i) 5 for i in lst1: 6 lst.remove(i) 7 print(lst)
>>>>>>>>>> [ ]
用一个新列表来记录原列表元素，然后循环新列表来删除原列表的元素
也可以用以下方法来循环删除元素
1 li = ['abc', 'bcd', 'cde', 'edf'] 2 for i in range(0, len(li)): # 循环len(li)次, 然后从后往前删除 3 li.pop() 4 print(li)
>>>>>>>>>> [ ]
注意: 由于删除元素会导致元素的索引改变, 所以容易出现问题. 尽量不要再循环中直接去删 除元素. 可以把要删除的元素添加到另一个集合中然后再批量删除.
字典也不能在循环的时候更改大小，如果想要删除字典中的元素，需要使用一个列表来记录要删除的元素，然后遍历列表来删除字典中的元素
1 dic = {'yang': 25, 'pan': 24, 'liu': 21}
2 lst =[]
3 for k in dic:
4 lst.append(k)
5 for i in lst:
6 del dic[i]
7 print(dic)
>>>>>>>>>> { }
fromkeys() : 可以通过列表来创建一个字典
1 s = dict.fromkeys(['林俊杰', '陈奕迅', '周杰伦', '黄家驹'], 'shuai') 2 print(s)
>>>>>>>>> {'林俊杰': 'shuai', '陈奕迅': 'shuai', '周杰伦': 'shuai', '黄家驹': 'shuai'}
也可以通过字典的对象来创建
1 dic = {} 2 s = dic.fromkeys(['林俊杰', '陈奕迅', '周杰伦', '黄家驹'], 'shuai') 3 print(s)
>>>>>>>>> {'林俊杰': 'shuai', '陈奕迅': 'shuai', '周杰伦': 'shuai', '黄家驹': 'shuai'}
-
列表的介绍:
- 表现形式:[ ],列表可以放大量数据,不限制数据类型,里边的内容用逗号隔开.
- 列表和字符串一样也有索引和切片
-
常用功能:
增:
append(): 给列表追加元素,添加的元素放在列表末尾
insert(index,object): 把元素插入到列表的index位置,涉及到元素的移动
extend(): 迭代添加,括号里可以是字符串也可以是一个列表,将字符串或列表里的每一个元素依次添加到原列表的末尾
- append():
1 lst = ["周杰伦", "王力宏", "周润发"] 2 lst.append("伍佰") # 向列表中添加一个元素, 元素放在末尾. 把一个元素追加到列表的末尾 3 print(lst)
- insert():
1 lst = ["周杰伦", "王力宏", "周润发"] 2 lst.insert(1, "马化腾") # 把元素插入到指定位置. 元素的移动 3 print(lst)
- extend():
1 lst = ["周杰伦", "王力宏", "周润发"] 2 lst.extend(["马云", "王健林", "李嘉诚"]) # 迭代添加 3 print(lst)
删:
pop(): 删除列表的最后一个元素,可以用一个变量来接受被删除的元素
pop(index): 删除列表index位置的元素
remove(object): 删除指定元素,但只删除列表的第一个指定元素,其余的不删
clear(): 清除列表里的全部元素,使之变成一个空列表
del 列表名[index1 : index2 : 步长 ]: 切片删除,有固定的格式,删除index1到index2的内容,后边可以选择切片的方向
- pop():
1 lst = ["盖伦", "大白梨", "提莫", "大白梨"] 2 e = lst.pop() # 返回删除的元素, 删除最后一个 3 print(e)
- remove()：
1 lst = ["盖伦", "大白梨", "提莫", "大白梨"] 2 lst.remove("大白梨") 3 print(lst)
- clear():
1 lst = ["盖伦", "大白梨", "提莫", "大白梨"] 2 lst.clear() 3 print(lst)
- del():
1 lst = ["盖伦", "大白梨", "提莫", "大白梨"] 2 del lst[1:] 3 print(lst)
改:
1.索引修改 通过列表索引来拿到对应的值进行修改操作
2.切片修改 迭代修改
- 索引修改:
1 lst = ["太白", "五色", "银王", "日天"] 2 lst[0] = "太黑" 3 print(lst) 4 lst[2] = "银角大王" 5 print(lst)
- 切片修改:
1 lst[1:3] = "马化腾" # 迭代修改 2 print(lst) 3 lst[1:3] = ["周杰伦", "他媳妇", "王力宏媳妇"] 4 print(lst)
查:
列表是⼀一个可迭代对象, 所以可以进行for循环
1 lst = ["舒克贝塔", "黑猫警长", "熊大熊二", "葫芦娃", "吴佩琪"] 2 for el in lst: # element 3 print(el)
常用操作:
count(): 查询字符出现次数
sort(): 把列表元素进行排序
len(): 计算长度
- count():
1 lst = ["太白", "太黑", "五色", "银王", "日天", "太白"] 2 c = lst.count("太白") # 查询太白出现的次数 3 print(c)
- sort():
1 lst = [1, 11, 22, 2] 2 lst.sort() # 排序. 默认升序 3 print(lst) 4 lst.sort(reverse=True) # 降序 5 print(lst)
- len():
1 l = len(lst) # 列表的长度 2 print(l)
列表的嵌套:
采用降维操作.一层一层的看就好.
1 lst = [1, "太白", "wusir", ["马虎疼", ["可口可乐"], "王健林"]] 2 3 # 找到wusir 4 print(lst[2]) 5 6 # 将wusir拿到. 然后首字母大写. 再扔回去 7 lst[2] = lst[2].capitalize() 8 print(lst) 9 10 # 把太白换成太黑 11 lst[1] = lst[1].replace("白", "黑") 12 print(lst)
-
元组的介绍:
- 不可变的列表. 只读列表. 有索引和切片.
- 不可变的是它内部子元素. 如果子元素是列表. 列表中的元素是可以变的.
- 元组的基本操作:
1 tu = (1, "太白", "李白", "太黑", "怎么黑") 2 print(tu) 3 4 print(tu[0]) 5 print(tu[2]) 6 print(tu[2:5]) # 切片之后还是元组 7 8 9 10 # for循环遍历元组 11 for el in tu: 12 print(el)
>>>>>>小提示:元组也有count() , sort() , len() 等操作
-
set集合
- 集合的特点: 不重复，无序的，用{ }表示
- 注意: set集合中的元素必须是可hash的, 但是set本身是不可hash得. set是可变的.
- 使用set的不重复特性来为列表去重
1 lst = ['影流之主', '疾风剑豪', '诡术妖姬', '放逐之刃', '放逐之刃', '疾风剑豪', '卡牌大师'] 2 s = set(lst) 3 lst = list(s) 4 print(lst)
>>>>>>>>>>> ['卡牌大师', '放逐之刃', '疾风剑豪', '诡术妖姬', '影流之主']
-
集合的增删改查:
增 :
add() : # 重复的内容不会被添加进去
update() : 迭代添加
-
add() :
1 s = {'疾风剑豪', '影流之主', '诡术妖姬', '卡特琳娜', '卡牌大师', '九尾妖狐', '光辉女郎'}
2 s.add('刀锋之影')
3 print(s)
>>>>>>>>>> {'卡特琳娜', '疾风剑豪', '光辉女郎', '诡术妖姬', '影流之主', '刀锋之影', '卡牌大师', '九尾妖狐'}
-
update() :
1 s = {'疾风剑豪', '影流之主', '诡术妖姬', '卡特琳娜', '卡牌大师', '九尾妖狐', '光辉女郎'}
2 s.update('刀锋之影')
3 print(s)
>>>>>>>>>> {'刀', '卡牌大师', '卡特琳娜', '疾风剑豪', '锋', '之', '光辉女郎', '影流之主', '九尾妖狐', '诡术妖姬', '影'}
删 :
pop() : 随机删除一个
remove() : 指定元素删除，如果指定的 元素不存在，则会报错
clear() : 清空集合
1 s = {"刘嘉玲", '关之琳', "王祖贤", "张曼玉", "李若彤"}
2 item = s.pop() # 随机弹出⼀一个.
3 print(s)
4 print(item)
5
6
7 s.remove("关之琳") # 直接删除元素 #
8 s.remove("马虎疼") # 不不存在这个元素. 删除会报错
9 print(s)
10
11
12 s.clear() # 清空set集合.需要注意的是set集合如果是空的. 打印出来是set() 因为要和 dict区分的.
13 print(s) # set()
改 :
集合不能修改
查 :
for 循环迭代
-
集合常用操作:
-
交集:
-
1 lst = {'林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'}
2 lst1 = {'周杰伦', '周星星', '周润发', '周树人', '林俊杰'}
3 print(lst & lst1)
# 4 print(lst.intersection(lst1))
>>>>>>>>> {'林俊杰'}
-
-
并集:
-
1 lst = {'林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'}
2 lst1 = {'周杰伦', '周星星', '周润发', '周树人', '林俊杰'}
3 print(lst | lst1)
4 # print(lst.union(lst1))
>>>>>>>>>> {'黄家驹', '周杰伦', '毛不易', '周润发', '陈奕迅', '周树人', '周星星', '林俊杰', '薛之谦'}
-
-
差集:
-
1 lst = {'林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'}
2 lst1 = {'周杰伦', '周星星', '周润发', '周树人', '林俊杰'}
3 print(lst - lst1)
4 # print(lst.difference(lst1))
>>>>>>>>> {'毛不易', '陈奕迅', '薛之谦', '黄家驹'}
-
-
反交集:
-
1 lst = {'林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'}
2 lst1 = {'周杰伦', '周星星', '周润发', '周树人', '林俊杰'}
3 print(lst ^ lst1)
4 # print(lst.symmetric_difference(lst1))
>>>>>>>>> {'周杰伦', '陈奕迅', '毛不易', '周润发', '黄家驹', '薛之谦', '周树人', '周星星'}
-
-
子集:
-
1 lst = {'林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'}
2 lst1 = {'周杰伦', '周星星', '周润发', '周树人', '林俊杰'}
3 print(lst < lst1)
4 # print(lst.issubset(lst1))
>>>>>>>>> False
-
-
超集:
-
1 lst = {'林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'}
2 lst1 = {'周杰伦', '周星星', '周润发', '周树人', '林俊杰'}
3 print(lst > lst1)
4 # print(lst.issuperset(lst1))
>>>>>>>>> False
-
字典的介绍:
1.用大括号{} 括起来. 内部使用key:value的形式来保存数据
2.注意:字典的key必须是可哈希的. 不可变的, value 没有限制
3.字典保存顺序不是按照我们输入的顺序保存的
-
字典的操作方法：
增：
通过key添加，key不存在于原字典中才可添加，不然会替代原先的value。
1 dic = {'林俊杰': '圣所', '薛之谦': '演员', '华晨宇': '悟空', '张杰': 100}
2 dic['jc'] = "说散就散"
3 print(dic)
setdefault() :从字典末尾添加元素
1 dic = {'林俊杰': '圣所', '薛之谦': '演员', '华晨宇': '悟空', '张杰': 100}
2 dic.setdefault("cat", "study cat sing")
3 dic.setdefault("cat", "la ji") # 如果字典中已经包含了这个key,将不再保存
4 print(dic)
删：
pop（）:删除字典中的元素，并返回删除的元素，可用变量接收
1 dic = {1: 'Java', 2: 'c', 3: 'c++', 4: 'python'}
2 ret = dic.pop(3) # 通过key删除元素,返回这个元素的value值
3 print(ret)
4 print(dic)
del : 删除字典中的元素
1 dic = {1: 'Java', 2: 'c', 3: 'c++', 4: 'python'}
2 del dic[1]
3 print(dic)
items（）：随机删除
1 dic = {1: 'Java', 2: 'c', 3: 'c++', 4: 'python'}
2 ret = dic.popitem() # 随机删除一个元素,返回一个元组
3 print(dic)
4 print(ret)
clear（）：清空字典中所有元素
dic = {1: 'Java', 2: 'c', 3: 'c++', 4: 'python'}
dic.clear()
print(dic)
改：
dict[存在的值] = 新值 相当于赋值
dict.update(dict2) 把dict2的键值对（k-v）更新到dict中
1 dic1 = {"李晨":"范冰冰", "邓超":"孙俪", "王祖蓝":"李亚男"}
2 dic2 = {"李晨":"张馨予", "郑凯":"baby", "王宝强":"马蓉"}
3 dic1.update(dic2) # 把dic2中的内容更新到 dic1 , 如果存在了key. 替换. 如果不存在,添加
4 print(dic1)
5 print(dic2)
查：
get（）：查询字典中元素
1 dic = {"及时雨":"宋江", "小李广":"花荣", "黑旋风":"李逵", "易大师":"剑圣"}
2 print(dic.get("易大师", "余小C")) # 如果key不存在. 返回None
setdefault（）：字典中已经存在的key将不会再被添加，从而达到查询的效果
1 dic = {"及时雨":"宋江", "易大师":"剑圣"}
2 dic.setdefault("及时雨", "诺克萨斯") # 可以帮我们查询
3 print(dic)
dict[key] : 通过key查询字典中的元素
1 dic = {"及时雨":"宋江", "小李广":"花荣", "黑旋风":"李逵", "易大师":"剑圣"}
2 print(dic["及时雨"])
-
字典的常用操作：
- keys() 返回所有字典的key的集合(高仿列表)
1 dic = {"及时雨":"宋江", "易大师":"剑圣", "维恩":"暗影猎手"}
2 for key in dic.keys(): # 可以进行迭代循环
3 print(key)
-
- values() 返回所有的value的集合
1 dic = {"及时雨":"宋江", "易大师":"剑圣", "维恩":"暗影猎手"}
2 for value in dic.values():
3 print(value)
-
- items() 返回键值对. 元组
1 dic = {"及时雨":"宋江", "易大师":"剑圣", "维恩":"暗影猎手"}
2 for k, v in dic.items():
3 print(k , v)
-
解构，解包
1 a, b = (1, 2) 2 print(a) 3 print(b)
-
字典的嵌套：
1 dic = { 2 "name":"汪峰", 3 "age": 58, 4 "wife":{ 5 "name":"国际章", 6 "salary": 180000, 7 "age": 37 8 }, 9 "children":[ 10 {"name":"老大", "age": 18}, 11 {"name":"老二", "age": 118} 12 ] 13 } 14 print(dic["children"][1]["age"]) 15 16 print(dic["wife"]['salary'])
六、文件操作
-
文件操作概念:
使用python来读写文件是非常简单的操作. 我们使用open()函数来打开一个文件, 获取到文 件句柄. 然后通过文件句柄就可以进行各种各样的操作了. 根据打开方式的不同能够执行的操作也会有相应的差异.
-
文件操作方式: r , w , a , r+ , w+ , a+ , rb , wb , ab , r+b , w+b , a+b (默认使用r打开)
- 文件操作 r （只读） 只能进行读取操作 read(n) n只能为数字，表示读取到第几个位置，n为几，读取位置就截止到第几个字符
1 f = open('info', 'r', encoding='utf-8') 2 # s = f.read() # 读取全部内容 3 s = f.read(3) # 默认从头开始读取，读取到第三个位置 ， 如果再次读取，会从当前位置（光标处）开始读取 4 f.close() 5 print(s)
-
- 文件操作 w （写入） 只要用w写入内容，文件原本的内容就会全部删除
1 f = open('info', 'w', encoding='utf-8') 2 f.write('影流之主 劫') 3 f.flush() 4 f.close()
-
- 文件操作 a （追加） 可以在不该原文件内容的情况下添加新的内容
1 f = open('info', 'a', encoding='utf-8') 2 f.write(' 九尾妖狐 阿狸') 3 f.flush() 4 f.close()
-
- 文件操作 r+ （读写） 打开文件可以进行读取和写入的操作 注意：如果先进行写入的操作，那么读取时只能读取到写入之后的内容
1 f = open('info', 'r+', encoding='utf-8') 2 f.write(' 熔岩巨兽 墨菲特') # 如果先写再读，写入的内容会从开头开始覆盖，写入多少内容就会覆盖多少内容，然后光标会停在写入内容结束的位置 3 s = f.read() # 写入之后读取，会从光标处开始读取剩余的全部内容 所以正确的顺序应该是先读取再写入 4 f.flush() 5 f.close() 6 print(s)
1 # 先读取再写入 2 f = open('info', 'r+', encoding='utf-8') 3 s = f.read() # 先读取文件全部内容，光标会停留在最后 4 print(s) 5 f.write(" 熔岩巨兽 墨菲特") # 然后在光标处添加内容 6 f.flush() 7 f.close()
-
- 文件操作 w+ （写读） 先将原文件的内容清空，然后写入内容，最后再读取内容，但是读取是读不到内容的（不常用）
1 f = open('info', 'w+', encoding='utf-8') 2 f.write('诺克萨斯之手 德莱厄斯') # 清空文件，添加内容 3 s = f.read() # 读取文件，但是读取的内容为空 4 f.flush() 5 f.close() 6 print(s)
-
- 文件操作 rb （只读 非文本格式使用） 读取出来的数据是bytes类型, 在rb模式下. 不能选择encoding字符集.
1 f = open('info', 'rb') 2 s = f.read() # 读取的内容直接就是字节 3 print(s) 4 f.close()
-
- 文件操作 readline() 逐行读取，将文件内容一行一行的显示出来，（会出现换行,可用 strip（）来去除空格，换行符和制表符）
1 f = open('info', 'r', encoding='utf-8') 2 s = f.readline().strip() 3 s1 = f.readline().strip() 4 s2 = f.readline().strip() 5 print(s) 6 print(s1) 7 print(s2) 8 f.close()
-
- 文件操作 readlines（） 将每一个行形成一个元素，放到一个列表中，将所有内容都读取出来（不常用）
1 f = open('info', 'r', encoding='utf-8') 2 s = f.readlines() 3 print(s) 4 f.close()
文件操作 seek() seek(n) n是光标的位置，n的单位是字节（byte） utf-8编码下，一个汉字等于3个字节
seek() 使用方式:
seek(0) 移动光标到开头位置
seek(0,2) 移动光标到结尾位置
1 f = open("小娃娃", mode="r+", encoding="utf-8") 2 f.seek(0) # 光标移动到开头 3 content = f.read() # 读取内容, 此时光标移动到结尾 4 print(content) 5 6 f.seek(0) # 再次将光标移动到开头 7 f.seek(0, 2) # 将光标移动到结尾 8 content2 = f.read() # 读取内容. 什什么都没有 9 print(content2) 10 11 f.seek(0) # 移动到开头 12 f.write("张国荣") # 写⼊入信息. 此时光标在9 中⽂文3 * 3个 = 9 13 f.flush() 14 f.close()
文件修改: 创建新文件. 把修改后的内容写入新文件. 删除老文件. 重命名新文件
1 import os 2 3 with open("吃的", mode="r", encoding="utf-8") as f1, 4 open("吃的_副本", mode="w", encoding="utf-8") as f2: 5 for line in f1: 6 s = line.replace("菜", "肉") 7 f2.write(s) 8 9 os.remove("吃的") # 删除文件 10 os.rename("吃的_副本", "吃的") # 重命名文件
七、编码解码
-
编码
-
最早的编码是ASCII码,美国人创建的. 8位 1字节
-
gbk 国标码 16位 2字节
-
unicode 万国码 32 位 4字节
-
utf-8 : 英文 8位 1字节 欧洲 16位 2字节 中文 24位 3字节
-
计算机存储单位:
8 bit ==> 1 byte
1024 byte ==> 1 kb
1024 kb ==> 1 mb
1024 mb ==> 1 gb
1024 gb ==> 1 tb
1024 tb ==> 1 pb
-
is 和 == 的区别
-
id（） 通过id()我们可以查看到⼀一个变量表示的值在内存中的地址.
-
1 a = "刀下生，刀下死" 2 b = "刀下生，刀下死" 3 print(id(a)) 4 print(id(b))
>>>>>>>>>1654269828768
>>>>>>>>>1654269828768
>>>>>>>>>两个字符串地址相同
1 a = 123
2 b = 123
3 print(id(a),id(b))
>>>>>>>>>140708405633888 140708405633888
>>>>>>>>>两个数字地址也相同
1 a = ['yangxianqiang', 'pandeyong', 'hashiqi'] 2 b = ['yangxianqiang', 'pandeyong', 'hashiqi'] 3 print(id(a), id(b))
>>>>>>>>>2477147120200 2477147120264
>>>>>>>>>两个列表地址不同
1 a = ('abc', 2, 3, 4) 2 b = ('abc', 2, 3, 4) 3 print(id(a), id(b))
>>>>>>>>>2920342876392 2920342876392
>>>>>>>>>两个元组地址也相同
1 a = {1: 'xiazi', 2: 'yasuo', 3: 'feizi'}
2 b = {1: 'xiazi', 2: 'yasuo', 3: 'feizi'}
3 print(id(a), id(b))
>>>>>>>>>>2244009621904 2244009621976
>>>>>>>>>>两个字典地址也不相同
-
》》》》》》结论（仅供参考）
小数据池(常量池): 把我们使用过的值存储在⼩小数据池中.供其他的变量使用.
小数据池给数字和字符串使用, 其他数据类型不存在.
对于数字: -5~256是会被加到小数据池中的. 每次使用都是同一个对象.
对于字符串:
1. 如果是纯文字信息和下划线. 那么这个对象会被添加到小数据池
2. 如果是带有特殊字符的. 那么不会被添加到小数据池. 每次都是新的
3. 如果是单一字母*n的情况. 'a'*20, 在20个单位内是可以的. 超过20个单位就不会添加 到小数据池中
注意(一般情况下): 在py文件中. 如果你只是单纯的定义一个字符串. 那么一般情况下都是会 被添加到小数据池中的. 我们可以这样认为: 在使用字符串的时候, python会帮我们把字符串串进行缓存, 在下次使用的时候直接指向这个字符串即可. 可以节省很多内存.
- is : is比较的就是id()计算出来的结果. 由于id是帮我 们查看某数据(对象) 的内存地址. 那么is比较的就是数据(对象)的内存地址.
- == : 双等表示的是判断是否相等, 注意. 这个双等比较的是具体的值.而不是内存地址
1 s1 = "哈哈" 2 s2 = "哈哈" 3 print(s1 == s2) # True print(s1 is s2) 4 # True 原因是有小数据池的存在 导致两个变量指向的是同一个对象 5 l1 = [1, 2, 3] 6 l2 = [1, 2, 3] 7 print(l1 == l2) # True, 值是⼀一样的 8 print(l1 is l2) # False, 值是假的
>>>>>>>>>>True
>>>>>>>>>>True
>>>>>>>>>>False
总结:
is 比较的是地址
== 比较的是值
-
编码的补充
-
编码回顾:
-
ASCII : 英文 8bit 1byte
GBK : 中文 16bit 2byte
Unicode : 万国码 32bit 4byte
utf-8 : 英文 8bit 1byte
欧洲 16bit 2byte
中文 24bit 3byte
-
-
bytes的表现形式:
-
1) : 英文 b'alex' 英文的表现形式和字符串没什么两样
2) : 中文 b'xe4xb8xad' 这是一个汉字的UTF-8的bytes表现形式
-
-
编码 : 字符串在传输时转化成bytes=> encode(字符集)来完成
-
1 s = "alex" 2 print(s.encode("utf-8")) # 将字符串编码成UTF-8 3 print(s.encode("GBK")) # 将字符串编码成GBK
>>>>>>>>>>b'alex'
>>>>>>>>>>b'alex'
1 s = "中" 2 print(s.encode("UTF-8")) # 中文编码成UTF-8 3 print(s.encode("GBK")) # 中文编码成GBK
>>>>>>>>>>b'xe4xb8xad'
>>>>>>>>>>b'xd6xd0'
-
-
解码 : 我们可以使用decode()来进行解码操作. 把bytes类型的数据还原回我们熟悉的字符串
-
1 s = "我叫李李嘉诚" 2 print(s.encode("utf-8")) # b'xe6x88x91xe5x8fxabxe6x9dx8exe5x98x89xe8xafx9a' 3 print(b'xe6x88x91xe5x8fxabxe6x9dx8exe5x98x89xe8xafx9a'.decode("utf-8")) # 解码
编码和解码的时候都需要制定编码格式
1 s = "我是⽂字" 2 bs = s.encode("GBK") # 我们这样可以获取到GBK的⽂文字 3 # 把GBK转换成UTF-8 4 # 首先要把GBK转换成unicode. 也就是需要解码 5 s = bs.decode("GBK") # 解码 6 # 然后需要进行重新编码成UTF-8 7 bss = s.encode("UTF-8") # 重新编码 8 print(bss)
八、深浅拷贝
-
深浅拷贝
赋值操作:
1 lst = ['林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易'] 2 lst1 = lst 3 lst1.append('周杰伦') 4 print(lst) 5 print(lst1)
>>>>>>>>>>> ['林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易', '周杰伦']
>>>>>>>>>>> ['林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易', '周杰伦']
对于list, set, dict来说, 直接赋值. 其实是把内存地址交给变量. 并不是复制一份内容. 所以. lst的内存指向和lst1是一样的. lst1改变了, lst也发生了改变
-
浅拷贝:
1 lst = ['yasuo', 'xiazi', 'yingliu'] 2 lst1 = lst.copy() 3 # lst1 = lst[:] # 切片也是复制 4 lst.append('shitouren') 5 lst1.append('jiqiren') 6 print(lst) 7 print(lst1)
>>>>>>>>>>>> ['yasuo', 'xiazi', 'yingliu', 'shitouren']
>>>>>>>>>>>> ['yasuo', 'xiazi', 'yingliu', 'jiqiren']
两个lst完全不一样. 内存地址和内容也不一样. 发现实现了内存的拷贝,浅拷贝只能实现第一层的拷贝
-
深拷贝:
1 import copy 2 3 lst = ['林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易', ['田馥甄', 'jc', '于文文']] 4 lst1 = copy.deepcopy(lst) 5 lst[5].append('杨钰莹') 6 print(lst) 7 print(lst1)
>>>>>>>>>>>>>> ['林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易', ['田馥甄', 'jc', '于文文', '杨钰莹']]
>>>>>>>>>>>>>> ['林俊杰', '陈奕迅', '黄家驹', '薛之谦', '毛不易', ['田馥甄', 'jc', '于文文']]
深度拷贝. 把元素内部的元素完全进行拷贝复制. 不会产生一个改变另一个跟着改变的问题