//********************************************* python 简介 *****************************************//
"""""
1. 什么是编程, 什么是编程语言?
编程: 用代码编写程序
编程语言: 用哪种语法规则来编写程序
a = 10 => 0101010(exe)
2. 编程语言分类
1. 编译型: C, go
一次性把源代码进行翻译
特点: 执行效率很高, 平台依赖性一般比较高
2. 解释型 javascript, python, ruby
逐行的对源代码进行翻译和运行
特点: 执行效率相对较低. 平台的依赖性不高
3. 什么是python? 优缺点?
python是一个叫龟叔的荷兰老头写的(89年)
擅长:
1. 爬虫
2. 自动化
3. 科学计算
4. 人工智能
"""""
//********************************************* cmd 上运行 *******************************************//
"""""
可以在cmd上运行：
方法1：先输入python
然后执行语句：print(4)
方法2：如果想在cmd上执行文件，要求：文件必须是xxx.py软件
然后，还是先执行python 一次，然后把文件拖入到cmd上(自动形成文件路径)
或者，输入 python 文件路径-----> 执行文件
总的格式：python解释器 py文件----> 执行py程序
"""""
//*********************************************** python 编译器推荐 **************************************//
1. 记事本
2. vscode
3. pycharm
4. jupyter notebook
//*********************************************** 注释 **********************************************//
注释: 是对代码进行解释和说明
注释是给人看的. 机器是不运行的.
print("你好呀, 我叫赛利亚")
# 单行注释
print("你才好呢. 我不是赛利亚")
"""
多行注释
写诗..
"""
'''
多行注释
'''
//************************************************ 变量 *********************************************//
变量: 可以发生改变的一个量. 变量是用来区分不同数据的. 可以指向一个内存空间, 帮我们存储一些数据
变量的命名规范:
1. 必须是数字或字母或下换线组成.
2. 不能是数字开头, 更不能是纯数字
3. 不能用python的关键字
4. 不要用中文
5. 不要太长
6. 要有意义
7. 推荐使用下换线命名或者驼峰命名
综上, 你的变量名一定要让人能看懂. 看的舒服.
diyi = "第一篇作文"
dier = "第二篇作文"
print(diyi)
print(dier)
a = 188
print(a)
a = 166
print(a)
a = 10
a1 = 10
a_1 = 11
_ = 11
1 = 188
1 + 1 = ? # 所以，肯定不能数字开头
樵夫 = "很帅"
print(樵夫)
# if for while async break True
zhonggongzhongyangguowuyuanliaoningshengdongxingxianlongquanshanzhuangyaoshanbuzhuguanjinglilibaoku = "药匣子"
qwer = "123"
name_of_teacher = "樵夫"
NameOfTeacher = "樵夫"
name = "阿拉斯加"
print(name) # 阿拉斯加
print("name") # name
//********************************************** 常量 **********************************************//
PI = 3.1415926
print(PI)
PI = 3
print(PI)
1. print(123)
2. 可以把所有的变量的字母变成大写就可以认为是常量
不存在绝对意义上的常量
//******************************************* 整数类型 *********************************************//
a = 10 # 整数
b = 20
print(a + b) # 加法运算
c = 1.25
print(c * 4)
# 字符串
s = '周润发'
print(s)
print("你好啊, 我叫赛利亚")
a = '''我家大门常打开, 用于：多行注释
欢迎你们到来
赶紧来,
我叫着火了'''
print(a)
name = "樵夫"
tedian = "帅爆了"
print(name + tedian)
print("周润发" * 5)
# 布尔值
print(100 > 30)
print(20 > 500)
# 可以直接赋值
a = True
a = 100 > 30
数据类型: 区分不同的数据. 不同的数据类型应该有不同的操作
数字: +-*/
整数, int
小数, float
文字: 展示
字符串: str (*****)
表示方式:
''
""
''' ''' 用于：多行注释
""" """ 用于：多行注释
操作:
+ 左右两端必须是字符串, 表示字符串连接操作
* 一个字符串只能乘以一个数字, 表示字符串重复的次数
print("haha"*5) hahahahahahahahahahahaha
布尔(bool): 条件判断
布尔值主要有两个:
True 真, 真命题
False 假, 假命题
100 > 30 -> 真
//********************************************** 简单交互 *******************************************//
a = input("请输入第一个数字:")
print(type(a)) # 用type来查看一个变量的数据类型 <class 'str'>
b = input("请输入第二个数字:")
a = int(a) 强制转换
b = int(b)
print(a + b)
变量 = input(提示语)
首先会在屏幕中显示出提示语, 用户输入内容. 然后把用户输入的内容交给前面的变量
坑: input()得到的结果一定是字符串
怎么把字符串转化成数字类型
py基础数据类型:
想把xxx转化成谁, 就用谁套起来
str => int int(str)
//******************************************** 条件判断 ************************************************//
# ======第一种======
money = 100
if money > 300:
print("铁锅炖")
print("回家")
# # ======第二种=====
money = input("请输入你兜里的钱:")
money = int(money)
if money > 500:
print("足疗")
else:
print("回家五姑娘")
# # =========第三种========
money = int(input("请输入你都里的钱:"))
if money > 1000:
if money > 5000:
print("充个会员卡")
else:
print('洗个脚就走')
else:
print("回家五姑娘")
# =========第四种========
money = int(input("请输入你都里的钱:"))
if money > 5000:
print("充卡")
elif money > 1000:
print("洗个脚回家")
else:
print("回家五姑娘")
if语句的语法规则:
1.
if 条件:
代码
如果条件成立就执行代码
如果不成立, 就不执行
2.
if 条件:
代码1
else:
代码2
如果条件成立, 执行代码1, 否则, 执行代码2
3.
if语句可以互相嵌套
if 条件:
if.....:
ss
else:
xx
else:
代码2
4.
if 条件1:
代码1
elif 条件2:
代码2
elif 条件3:
代码3
....
else:
xxxx
//************************************************** 循环 ******************************************//
while True: # 死循环
print("喷死你")
# # 用程序去数数, 从1~100
i = 1
while i <= 100:
print(i)
i = i + 1
# 1+2+3+4+5+6+7+8+9......+100 = ?
i = 1
s = 0
while i <= 100:
# print(i) # 从1 到 100 的没一个数
s = s + i # 累加
i = i + 1
print(s)
"""
i s
1 0+1
2 0+1+2
3 0+1+2+3
4
5
6
7
8
100 0+1+2+3+....+99 + 100
"""
# 1-2+3-4+5-6+7....-100 = ?
i = 1
s = 0
while i <= 100:
if i%2==0
s = s - i
if i%2!=0
s = s + i
i = i + 1
print(s)
可以让我们的代码重复的去执行
while循环:
while 条件:
代码
过程: 判断条件是否为真, 如果真, 执行代码. 然后再次判断条件. ....直到条件为假循环结束
//****************************************** break continue ****************************************//
while True:
content = input("请输入你要喷的内容(q结束喷人):")
if content == "q": # == 表示判断左右两端是否一致
break # 结束循环
print("发送给下路:", content)
# 从1-10
i = 1
while i <= 10:
if i == 4:
i = i + 1 细节：这里跟C语言/java 不一样！ 在python里面，4的时候返回，i还是4！！！不像别的语言自己跳成5
continue # 终止当前本次循环. 继续执行下一次循环
print(i)
i = i + 1
break: 让当前这个循环立即停止
continue: 停止当前本次循环. 继续执行下一次循环
//************************************************* for ********************************************//
s = "你好啊, 我叫赛利亚"
for c in s:
print("这一次循环得到的是: ", c)
这一次循环得到的是: 你
这一次循环得到的是: 好
这一次循环得到的是: 啊
这一次循环得到的是: ,
这一次循环得到的是:
这一次循环得到的是: 我
这一次循环得到的是: 叫
这一次循环得到的是: 赛
这一次循环得到的是: 利
这一次循环得到的是: 亚
for i in range(10): # 0~9
print(i)
0
1
2
3
4
5
6
7
8
9
for i in range(3, 10): # 3~9
print(i)
i = 1
while i < 10:
print(i)
i = i + 2
1
3
5
7
9
for i in range(1, 10, 2):
print(i)
字符串是可迭代的
for循环:
for 变量 in 可迭代的东西:
代码
把可迭代的东西中的每一项内容拿出来. 挨个的赋值给变量. 每一次赋值都要执行一次循环体(代码)
for循环想要计数. 必须借助于range
range(n): 从0数到n. 不包含n
range(m, n): 从m数到n, 不包含n
range(m, n, s): 从m数到n, 不包含n, 每次的间隔是s
平时用的多的是for循环, while循环用的多的是死循环
//********* pass ******//
a = 10
if a > 100:
pass
pass: 代码占位 .防止报错
//***************************************** 基础数据类型 ********************************************//
"""
int, float, bool
str (*****)
list (*****)
tuple (**)
set (*)
dict (*****)
bytes (****)
运算符 (***)
文件操作(****)
"""
# 本章内容大多数都是要记. 理解的东西不多.
# 在后面的学习中, 会经常的使用到本章内容.
//********* int,float,bool ******//
# int: 整数, 加减乘除, 大小比较
a = 10
# float: 小数, 浮点数
a = 10.5
print(a) # 10.5
print(10/3) # 3.3333333333333335
# 小数: 数据范围是无限的. 整数: 在某一个特定的区间内是可以表示的很清楚的.
# int 范围：1~100000000
# 0~1
# 计算机是一个二进制的产品: 0, 1
# 计算机表示一个小数是会有误差的.
#
# bool : 用来做条件判断的
# 取值范围: True, False
# 基础数据类型之间的转化
a = "10" # 字符串
print(type(a)) # <class 'str'>
b = int(a) # 把字符串转化成int()
print(type(b)) # <class 'int'>
a = 0 # 在python中, 所有的非零的数字都是 True, 零是False
b = bool(a)
print(type(b)) # <class 'bool'>
print(b) # False
while 1: # 死循环, 恒为真
print("还我钱")
s = "" # 在python中, 所有的非空字符串都是True, 空字符串是False
print(bool(s)) # False
# 综上, 在python的基本数据类型中, 表示空的东西都是False, 不空的东西都是True
lst = []
print(bool(lst)) # False
while 1:
content = input("请输入你要喷的内容:")
if content:
print("你要发给打野的内容:", content)
else: # 不输入内容，直接空格，那就退出！！
break
//************************************************ 字符串 *******************************************//
# 1. 字符串的格式化问题
# 我叫xxx, 我住在xxxx, 我今年xx岁, 我喜欢做xxxxx
name = input("请输入你的名字:")
address = input("请输入你的住址:")
age = int(input("请输入你的年龄:"))
hobby = input("请输入你的爱好:")
# %s 字符串占位
# %d 占位整数
# %f 占位小数
s = "我叫%s, 我住在%s, 我今年%d岁, 我喜欢%s" % (name, address, age, hobby)
s0 = "我叫%s" % name
print(s0)
s1 = "我叫{}, 我住在{}, 我今年{}岁, 我喜欢{}".format(name, address, age, hobby)
s2 = f"我叫{name},我叫{name},我叫{name},我叫{name},我今年{age}岁,我叫{name},我叫{name}" # f-string
print(s2)
2. 索引和切片
索引: 按照位置提取元素
s = "我叫周杰伦"
# 可以采用索引的方式来提取某一个字符(文字)
print(s[3]) # 杰 程序员都是从0开始数数
print(s[0]) # 我
print(s[-1]) # 伦 -表示倒数
切片: 从一个字符串中提取一部分内容
语法: s[start:end] 从start到end进行切片. 但是取不到end [start, end)
s = "我叫周杰伦,你呢? 你叫周润发吗?"
print(s[3:6]) # 杰伦, 从索引3位置进行切片, 切到6结束, 坑: 切片拿不到第二个位置的元素
print(s[0:5]) #我叫周杰伦
print(s[:5]) # 我叫周杰伦 如果start是从开头进行切片, 可以省略
print(s[6:]) # 你呢? 你叫周润发吗? 从start开始一直截取到末尾
# : 如果左右两端有空白. 表示开头或者结尾
print(s[:]) # 我叫周杰伦,你呢? 你叫周润发吗?
print(s[-3:-1]) # 发吗 目前还是只能从左往右切片。因为默认：s[-3:-1:1]
print(s[-1:-3]) # 没结果, 这里是坑!!!!无法输出
s = "我爱你"
可以给切片添加步长来控制切片的方向
print(s[::-1]) # -表示从右往左
语法: s[start:end:step] 从start切到end, 每step个元素出来一个元素
s = "abcdefghijklmnopqrst"
print(s[2:11:3]) # cfi
print(s[-1:-10:-3]) # tqn
==================================
3.字符串常规操作
字符串的操作一般不会对原字符串产生影响. 一般是返回一个新的字符串
3.1 字符串大小写转换
s = "python"
s1 = s.capitalize() # 第一个单词的首字母大写(后面单词不管)
print(s1) # Python
s = "I have a dream!"
s1 = s.title() # 所有单词的首字母大写
print(s1) # I Have A Dream!
s = "I ha麦合ve a dream!"
s1 = s.title()
print(s1) # I Ha麦合Ve A Dream! v也会大写！因为汉字中断了。
# "I ha麦合ve a dream!" 等价于 "I ha ve a dream!"
s = "I HAVE A DREAM"
s1 = s.lower() # 变成小写字母
print(s1) # i have a dream
s = "i have a dream"
s1 = s.upper() # 把所有字母变成大写字母
print(s1) # I HAVE A DREAM
# 如何忽略大小写来进行判断 => upper()
verify_code = "xAd1"
user_input = input(f"请输入验证码({verify_code}): ")
if verify_code.upper() == user_input.upper():
print("验证码正确")
else:
print("验证码不正确")
==================================
3.2 替换和切割(*)
strip() 去掉字符串左右两端的空白符(空格, \t, \n)
s = " 你好, 我叫 周杰伦 "
s1 = s.strip()
print(s1) # "你好, 我叫 周杰伦"
s2 = (s.strip()).replace(" ", "") # a.replace(" ", "") 去除内部的空格
print(s2) # 你好,我叫周杰伦
# 案例
username = input("请输入用户名:").strip() # " abc " ----> "abc"
password = input("请输入密码:").strip()
if username == "admin":
if password == "123456":
print("登录成功")
else:
print("登录失败!")
else:
print("登录失败!")
==================================
# 3.3 replace(old, new) 字符串替换
s = "你好啊, 我叫赛利亚"
s1 = s.replace("赛利亚", "周杰伦")
print(s1) # 你好啊, 我叫周杰伦
a = "hello i am a good man!"
a1 = a.replace(" ", "") # 去掉所有的空格
print(a1) # helloiamagoodman!
split(用什么切割) 字符串切割, 用什么切, 就会损失掉谁.
a = "python_java_c_c#_javascript"
lst = a.split("_") # 切割之后的结果会放在列表当中
print(lst) # ['python', 'java', 'c', 'c#', 'javascript']
lst = a.split("_java_")
print(lst) # ['python', 'c_c#_javascript']
replace(), split(), strip() => 记住
==================================
3.4 查找和判断
查找
s = "你好啊. 我叫周润发"
ret = s.find("周润发12312") # 返回如果是-1就是没有该字符串出现
print(ret)
ret = s.index("周润发12312") # 如果报错就是没有
print(ret)
print("周润发" in s) # in可以做条件上的判断
print("周润发" not in s) # not in 判断是否不存在
for c in s:
print (c)
判断
name = input("请输入你的名字:")
# 判断你是不是姓张
if name.startswith("张"): # 判断字符串是否以xxxxx开头, endswith()
print("你姓张")
else:
print("不姓张")
money = input("请输入你都里的钱:")
if money.isdigit(): # 判断字符串是否由整数组成.
money = int(money)
print("可以花钱了")
else:
print("对不起,您输入有误....")
if money.isdecimal():
# startswith(), isdigit(), in, not in, find
==================================
3.5 补充和总结
s = "hello"
print(len(s)) # 5 length 长度
s = "python_java_c_javascript"
lst = s.split("_")
print(lst) # ['python', 'java', 'c', 'javascript']
lst = ['赵本山', '王大拿', '大张伟', '马大哈']
# 用_把上面的人的名字连起来
s = "_".join(lst)
print(s) # 赵本山_王大拿_大张伟_马大哈
s = "".join(lst)
print(s) # 赵本山王大拿大张伟马大哈
# 总结:
"""
1. f"{变量}" 格式化一个字符串
2. 索引和切片:
索引: 从0开始的. []
切片: s[start: end: step], end位置的数据永远拿不到
3. 相关操作:
字符串操作对原字符串是不发生改变的.
1. upper() 在需要忽略大小写的时候
2. strip() 可以去掉字符串左右两端的空白(空格, \t, \n)
3. replace() 字符串替换
4. split() 对字符串进行切割
5. join() 拼接一个列表中的内容成为新字符串
6. startswith() 判断字符串是否以xxx开头
7. len() 字符串长度(内置函数)
字符串的循环和遍历
for c in s:
print(c) 字符串中的每一个字符
关于in:
1. 判断xxx是否在xxxx中出现了
2. for循环
"""
//********************************************* 列表 ************************************************//
# 4.1 ===================================================
# 定义: 能装东西的东西
# 在python中用[]来表示一个列表. 列表中的元素通过,隔开
# a = ["张三丰", "张无忌", "张绍刚", [1,2,3,True, ]]
# 特性:
# 1. 也像字符串一样也有索引和切片
# 2. 索引如果超过范围会报错
# 3. 可以用for循环进行遍历
# 4. 用len可以拿到列表的长度
lst = ["金毛狮王", "张绍刚", "张无忌", "郭麒麟"]
print(lst[0]) # 金毛狮王
print(lst[1:3]) # ['张绍刚', '张无忌']
print(lst[::-1]) # ['郭麒麟', '张无忌', '张绍刚', '金毛狮王']
print(lst[3652]) # 报错！！！ list index out of range (超出范围)
for item in lst:
print(item)
金毛狮王
张绍刚
张无忌
郭麒麟
print(len(lst)) # 4
# 4.2 ===================================================
列表的增删改查(*)
lst = []
# 向列表中添加内容
# append() 追加(*)
lst.append("张绍刚")
lst.append("赵本山")
lst.append("张无忌")
# insert() 插入
lst.insert(0, "赵敏")
# extend() 可以合并两个列表, 批量的添加
lst.extend(['武则天', "嬴政", "马超"])
print(lst)
# 删除
ret = lst.pop(3) # 给出被删除的索引. 返回被删除的元素
print(lst)
print(ret)
lst.remove("马超") # 删除某个元素(*)
print(lst)
# 修改
lst[4] = "恺" # 直接用索引就可以进行修改操作
print(lst)
查询
print(lst[3]) # 直接用索引进行查询操作
# 小练习(*):
# 把所有的姓张的人修改成姓王
lst = ['赵敏', '张绍刚', '张无忌', '武则天', '嬴政', '马超']
# lst[1] = "王绍刚"
# for item in lst: # 此时, 我们看不到元素的索引位置
for i in range(len(lst)): # len(lst)列表的长度 -> 可以直接拿到列表索引的for循环
item = lst[i] # item依然是列表中的每一项
if item.startswith("张"): # 等价于 (lst[i])[0]=="张"
new_name = "王"+item[1:]
print(new_name)
# 把新名字丢回列表(需要索引了?)
lst[i] = new_name # 修改
print(lst)
for i in range(len(lst)):
if (lst[i])[0]=="张": # 简化这样都可以。
lst[i] = "王"+(lst[i])[1:]
print(lst)
4.3 ==============================================
列表的其他操作(补充)
排序
lst = [1, 2, 3, "麻花藤", "武大郎"] # 列表会按照你存放的顺序来保存
print(lst) # [1, 2, 3, '麻花藤', '武大郎']
lst = [222, 444, 123, 43, 123,43243, 111]
lst.sort() # 对列表进行升序排序 等价于 lst.sort(reverse=False) [43, 111, 123, 123, 222, 444, 43243]
lst.sort(reverse=True) # reverse: 翻转 [43243, 444, 222, 123, 123, 111, 43]
print(lst)
# 列表的嵌套
lst = ["abc", "def", ["呵呵哒", "妈妈呀", "苦苦脊瓦", ["可乐", "scrapy", 123]], 'aed', "qpr"]
print(lst[2][3][1]) # scrapy
lst[2][3][1] = lst[2][3][1].upper() # scrapy--->SCRAPY
print(lst) # ['abc', 'def', ['呵呵哒', '妈妈呀', '苦苦脊瓦', ['可乐', 'SCRAPY', 123]], 'aed', 'qpr']
# 列表的循环删除(*)
lst = ['赵敏', '张绍刚', '张无忌', '武则天', '嬴政', '马超']
temp = [] # 准备一个临时列表, 负责存储要删除的内容
for item in lst:
if item.startswith("张"):
temp.append(item) # 把要删除的内容记录下来
# lst.remove(item) # 有bug
#为什么呢？因为，当你remove的那一刻，后面的元素补到remove的位置。如果后面也是remove的元素的话，会直接跳过的！！
# 两个开除的人在一起。开除一个，另一个立刻补过来这个位置。这个第二个人不会被删除！！有BUG
for item in temp:
lst.remove(item) # 去原列表中进行删除操作
print(lst) # ['赵敏', '武则天', '嬴政', '马超']
# 安全稳妥的循环删除方式:
# 将要删除的内容保存在一个新列表中. 循环新列表. 删除老列表
//***************************************** 元组 ***************************************************//
tuple 元组, 特点: 不可变的列表
t = ("张无忌", "赵敏", "呵呵哒")
print(t) # ('张无忌', '赵敏', '呵呵哒')
print(t[1:3]) # ('赵敏', '呵呵哒')
t[0] = "樵夫" # 报错！！不可修改！ 'tuple' object does not support item assignment
你固定了某些数据. 不允许外界修改
元组如果只有1个元素：(*), 需要在元素的末尾添加一个逗号
k=("哈哈") # String
t = ("哈哈",) # ()默认是优先级
# print( (1+3) * 6)
print(t) # ('哈哈',)
print(type(t)) # <class 'tuple'>
# 关于元组的不可变(坑), 本质：内存地址不能变.
t = (1, 2, 3, ["呵呵哒", "么么哒"]) # 列表内容可以变！！
t[3].append("哒哒哒")
print(t) # (1, 2, 3, ['呵呵哒', '么么哒', '哒哒哒'])
//********* 集合 ******//
set集合, set集合是无序的
k={}
print(type(k)) # <class 'dict'> 这是字典！！
s = {1,"呵呵哒",2,3}
print(type(s)) # <class 'set'>
print(s) # {1, 2, 3, '呵呵哒'}
s = {1, 2, 3, "呵呵", (1, 2, 3), []} # 报错！！ unhashable type: 'list' 不能有[]
print(s)
s = {1, 2, 3, "呵呵", (1, 2, 3)}
print(s) # {1, 2, 3, (1, 2, 3), '呵呵'}
# 不可哈希: python中的set集合进行数据存储的时候. 需要对数据进行哈希计算, 根据计算出来的哈希值进行存储数据
# set集合要求存储的数据必须是可以进行哈希计算的.
# 可变的数据类型, list, dict, set
# 可哈希: 不可变的数据类型, int, str, tuple, bool.
s=set()
s=tuple()
s=str()
s=list()
s = set() # 创建空集合
s.add("赵本山")
s.add("范伟")
s.add("麻花藤")
print(s)
s.pop() # 删除第一个！！！
print(s)
s.remove("范伟")
print(s)
# 想要修改. 先删除. 再新增
s.remove("麻花藤")
s.add("沈腾")
print(s)
for item in s:
print(item)
# 交集, 并集, 差集
s1 = {"刘能", "赵四", "皮长山"}
s2 = {"刘科长", "冯乡长", "皮长山"}
print(s1 & s2) # 交集
print(s1.intersection(s2))
print(s1 | s2) # 并集
print(s1.union(s2))
print(s1 - s2) # 差集
print(s1.difference(s2))
# 重要的作用: 可以去除重复
s1 = {"周杰伦", "昆凌", "蔡依林", "侯佩岑"}
print(s1)
s1.add("周杰伦")
print(s1)
lst = ["周杰伦", "昆凌", "蔡依林", "侯佩岑", "周杰伦", "昆凌", "蔡依林", "侯佩岑", "周杰伦", "昆凌", "蔡依林", "侯佩岑"]
print(lst)
print(list(set(lst))) # 去除重复之后的数据是无序的.
//******************************************* 字典 ************************************************//
# 首先, 字典是以键值对的形式进行存储数据的
# 字典的表示方式: {key:value, key2:value, key3:value}
dic = {"jay": "周杰伦", "金毛狮王": "谢逊"}
val = dic["金毛狮王"] # 用起来只是把索引换成了key
print(val)
# 字典的key必须是可哈希的数据类(不可变)
# 字典的value可以是任何数据类型
dic = {[]:123} # 不行！！！ []是可变的
print(dic)
dic = {"汪峰的孩子": ["孩子1", "孩子2"]} #可以！
# #7.2 字典的增删改查
#增加
dic = dict()
dic['jay'] = "周杰伦"
dic[1] = 123
print(dic) # {'jay': '周杰伦', 1: 123}
dic['jay'] = "昆凌" # 如果key已存在，则会覆盖！！！
print(dic) # {'jay': '昆凌', 1: 123}
dic.setdefault("jay", "胡辣汤") # 如果key已存在，则不会覆盖！！！
print(dic) # {'jay': '昆凌', 1: 123}
# 删除
dic.pop("jay") # 根据key去删除
print(dic)
# 查询
print(dic['jay10010']) # 如果key不存在. 程序会报错.
# 用法：当你确定你的key是没问题的, 可以用
print(dic.get('jay10086')) # 如果key不存在. 程序返回None.
# 用法：当不确定你的key的时候. 可以用
# None
a = None # 单纯的就是空, 表示没有的意思
print(type(a)) # <class 'NoneType'>
# 例子:
dic = {
"赵四": "特别能歪嘴",
"刘能": "老, 老四啊...",
"大脚": "跟这个和那个搞对象",
"大脑袋": "瞎折腾....",
}
name = input("请输入你想知道的我们村的人的名字: ")
val = dic.get(name) # 没有key:None
if val is None:
print("我门村没这个人~~~")
else:
print(val)
# 7.3 字典进阶操作 -- 循环和嵌套
dic = {
"赵四": "老一",
"刘能": "老二",
"大脚": "老三",
"大脑袋": "老四",
}
# 1. 可以用for循环, 直接拿到key
for key in dic:
print(key, dic[key])
# 赵四 老一
# 刘能 老二
# 大脚 老三
# 大脑袋 老四
# 2. 希望把所有的key全都保存在一部字典中
print(dic.keys()) # 拿到所有的key了 dict_keys(['赵四', '刘能', '大脚', '大脑袋'])
# 2. 希望把所有的key全都保存在一个列表中
print(list(dic.keys())) # 拿到所有的key了 ['赵四', '刘能', '大脚', '大脑袋']
# 3. 希望吧所有的value都放在一个列表中
print(list(dic.values())) # ['老一', '老二', '老三', '老四']
print(dic.values()) # 存放在字典中 dict_values(['老一', '老二', '老三', '老四'])
# 4. 直接拿到字典中的key和value
print(list(dic.items())) # [('赵四', '老一'), ('刘能', '老二'), ('大脚', '老三'), ('大脑袋', '老四')]
for item in dic.items():
key=item[0]
value=item[1]
print(ket ,value)
for item in dic.items( ): # 简化
key,value=item
print( ket, value )
for key, value in dic.items(): # 可以直接拿到字典的所有的key和value
print(key, value)
a, b = (1, 2) # 元组或者列表都可以执行该操作. 该操作被称为解构(解包)
print(a)
print(b)
# 字典的嵌套
wangfeng = {
"name": "汪峰",
"age": 18,
"wife": {
"name": "章子怡",
"hobby": "演戏",
"assistant": {
"name": "樵夫",
"age": 19,
"hobby": "打游戏"
}
},
"children": [
{"name": "孩儿1", "age": 13},
{"name": "孩儿2", "age": 10},
{"name": "孩儿3", "age": 8},
]
}
# 汪峰妻子的助手的名字
name = wangfeng['wife']['assistant']['name']
print(name)
# 给汪峰的第二个孩子加1岁
wangfeng['children'][1]['age'] = wangfeng['children'][1]['age'] + 1
print(wangfeng)
# # 7.4 补充. 关于字典的循环删除
dic = {
"赵四": "特别能歪嘴",
"刘能": "老, 老四啊...",
"大脚": "跟这个和那个搞对象",
"大脑袋": "瞎折腾....",
}
temp = [] # 存放即将要删除的key
for key in dic:
if key.startswith("大"):
temp.append(key)
# dic.pop(key) # dictionary changed size during iteration 不能改变字典的长度。
#怎么理解呢？因为，for key in dic 就是记住长度，然后从第一个位置开始遍历。
# 如果此时长度变了，算法会出问题的。 所以会报错~
for t in temp: # 循环列表, 删除字典中的内容 和列表的删除一样。
dic.pop(t)
print(dic)
//******************************************** bytes ***********************************************//
"""
1. 字符集和编码
0 1 <=> 1010101010 => 二进制转化成十进制 <=> 88
电脑如何进行存储文字信息
1000000 <=> a
ascii => 编排了128个文字符号. 只需要7个0和1就可以表示了. 01111111 => 1 byte => 8bit
ANSI => 一套标准, 每个字符 16bit, 2byte => 65536
00000000 01111111
到了中国, gb2312编码, 后来：gbk编码(windows 默认的就是这个)
01000000 01010101 => 中
到了日本, JIS编码
01000000 01010101 => え
发现，还是不统一！！为了解决这个情况，引出了：万国码
Unicode: 万国码. 中文
早期Unicode没有意识到这个问题. UCS-2 2个字节.
后来发现不够，进行了扩充, UCS-4 4个字节。
00000000 00000000 00000000 01111111
如果定死了大小为4个字节，对英文只需要一个字节的编码，非常浪费空间大小。引出了可变长度的utf
utf: 是可变长度的unicode. 可以进行数据的传输和存储 -> 行书, 草书, 隶书
utf-8: 最短的字节长度8
英文: 8bit, 1byte
欧洲文字: 16bit, 2byte
中文: 24bit, 3byte
utf-16: 最短的字节长度16
总结:
1. ascii: 8bit, 1byte
2. gbk: 16bit, 2byte windows默认
3. unicode: 32bit, 4byte(没法用, 只是一个标准)
4. utf-8: mac默认
英文: 8bit, 1byte
欧洲: 16bit, 2byte
中文: 24bit, 3byte
gbk和utf-8不能直接就进行转化.
我军密码本 -> 文字 -> 敌军密码本
2. bytes
程序员平时遇见的所有的数据最终单位都是字节byte
"""
s = "周杰伦"
bs1 = s.encode("gbk") # b'xxxx' bytes类型 一个字节
bs2 = s.encode("utf-8")
print(bs1) # b'\xd6\xdc\xbd\xdc\xc2\xd7' 总共：6个字节
print(bs2) # b'\xe5\x91\xa8\xe6\x9d\xb0\xe4\xbc\xa6' 总共：9个字节
# 怎么把一个gbk的字节转化成utf-8的字节
bs = b'\xd6\xdc\xbd\xdc\xc2\xd7'
# 先变成文字符号(字符串)
s = bs.decode("gbk") # 解码
bs2 = s.encode("utf-8") # 重新编码
print(bs2) # b'\xe5\x91\xa8\xe6\x9d\xb0\xe4\xbc\xa6'
# 1. str.encode("编码") 进行编码
# 2. bytes.decode("编码") 进行解码
s = "abcdefg"
print(s.encode("gbk")) # b'abcdefg'
print(s.encode("utf-8")) # b'abcdefg'
# UTF-8: a:01100001 (一个字节) GBK: a:00000000 01100001 (两个字节)
# 实际表示上，0可以省略。所以：字母的表示上：UTF-8 等价于 GBK
s = "周aaa杰"
bs1 = s.encode("gbk")
bs2 = s.encode("utf-8")
print(bs1) # b'\xd6\xdcaaa\xbd\xdc' 可以看成 b'\xd6\xdc aaa \xbd\xdc' 拆开看
print(bs2) # b'\xe5\x91\xa8aaa\xe6\x9d\xb0' 可以看成 b'\xe5\x91\xa8 aaa \xe6\x9d\xb0'
//******************************************** 运算符 ***********************************************//
"""
1. 算数运算
+ - * / % //
2. 比较运算
> < >= <= == !=
3. 赋值运算
= +=, -=, *=.....
a += b
a = a + b
n = 1
sum = 0
while n <= 100:
sum = sum + n # sum += n
n = n + 1 # n += 1
4. 逻辑运算
1. and, 并且, 左右两端同时成立. 结果才能成立
2. or, 或者, 左右两端有一个成立. 结果就成立
3. not, 非, 非真既假, 非假既真.
当and和or以及not同时出现的时候. 最好呢. 加上括号. 不会产生歧义或者不易理解的问题
如果没有括号怎么办?
记住运算顺序:
从左往右：先算括号 > 算not > and > or
5. 成员运算
in 判断xxx是否在xxxx中出现了
not in 判断xxx是否不在xxxx中出现了
"""
a = 20
b = 3
# 20 / 3 = 6.....2
print(a % b) # 2 (余数)
print(a // b) # 6 (商)
print(a / b) # 6.666666666666667
#让用户输入一个数字. 判断是否是35的倍数
n = int(input("来个数: "))
if n % 35 == 0:
print("是35的倍数")
else:
print("不是35的倍数")
a = 20
b = 20
print(a != b) # True
a = 30
b = 40
# 互换操作
temp = a # 备份, 有桌子
a = b
b = temp
# 下面代码仅适用于python
a, b = b, a
print(a)
print(b)
# 本质： (a,b)=(b,a) 元组的结构互换
# 逻辑运算
print(True and True and True and False)
print(False or True or False or False)
print( not False)
# 模拟用户登录.
username = input("用户名:")
password = input("密码:")
if username == "admin" and password == "123456":
print("登录成功")
else:
print("登录失败")
print(True and False or True and False or not True and True or False)
运算顺序:从左往右，先not:
print(True and False or True and False or (not True)=false and True or False)
再算and:
print((True and False)=false or (True and False)=false or (false and True)=false or False)
最后算or:
print(false or false or false or False) 直接看出来：false (但凡有一个True，就是True)
最后结果：False
lst = [1,2,3,4,5,]
print(3 in lst) # True
print(666 not in lst) # True
//****************************************** 文件操作 ************************************************//
"""
1. 找到这个文件. 双击打开它
open(文件路径, mode="", encoding="")
文件路径:
1. 绝对路径 (不安全：发送给别人，绝对路径不统一)
d:/test/xxxx.txt
2. 相对路径
相对于当前你的程序所在的文件夹
../ 上一层文件夹
mode:
r : read 读取
w : write 写
a : append 追加写入
b : 读写的是非文本文件 -> bytes
with: 上下文, 不需要手动去关闭一个文件
修改文件:
1. 从源文件中读取内容.
2. 在内存中进行调整(修改)
3. 把修改后的内容写入新文件中
4. 删除源文件. 将新文件重命名成源文件
"""
import os # 和操作系统相关的模块引入 删除文件/修改文件名
import time # 和时间相关的模块
f = open("国产自拍.txt", mode="r", encoding="utf-8") # 相当于插着管子，通道。 流向：文件 ---> 我
line = f.readline() # 去掉字符串左右两端的空白. 空格, 换行, 制表符
print(line)
line = f.readline() # 去掉字符串左右两端的空白. 空格, 换行, 制表符
print(line)
输出：
葫芦娃
我的葫芦
为什么会留一个空行？
因为，文本文件：葫芦娃 \n
我的葫芦 \n 末尾有一个换行符。那就把 \n 删掉~~
line = f.readline().strip() # 去掉字符串左右两端的空白. 空格, 换行, 制表符
print(line)
line = f.readline().strip()
print(line) 输出：葫芦娃
我的葫芦
细节：content = f.read() 会读剩余内容！！！ (之前读过的内容，不会出现)
line = f.readline() # 去掉字符串左右两端的空白. 空格, 换行, 制表符
print(line)
content = f.read() # 全部读取 真正的文件传输
print(content)
细节：content = f.read() 会读剩余内容！！！ 因为之前没读过，那就所有都读完了。后面来的没办法读！
content = f.read( ) # 全部读取
line = f.readline() # 不会输出。因为 f.read()把内容都读完了
print(line)
细节： 这里所说的“读 read” 和 “输出”一样的。不然，你可能觉得：我读完，再读一遍为啥不行？
但是，你站在“输出”的角度，就理解了。输出玩了，没办法在输出~~哈哈
f = open("国产自拍.txt", mode="r", encoding="utf-8") # 相当于插着管子，通道。 流向：文件 ---> 我
content = f.read() # 全部读取 真正的文件传输
print(content)
line = f.readline().strip() # 去掉字符串左右两端的空白. 空格, 换行, 制表符 (去掉文本的\n)
print(line)
line = f.readline().strip()
print(line)
line = f.readline().strip()
print(line)
输出结果：葫芦娃
我的葫芦
一根藤上七朵花
content = f.readlines()
print(content) # ['葫芦娃\n', '我的葫芦\n', '一根藤上七朵花\n'] 通过这里也能看得出来文本行末，有 '\n'
print("呵呵哒") # print内部存在一个换行 # 文本行末，也有一个换行\n
print("么么哒")
最重要的一种文本读取方式(必须掌握)
for line in f: # 从f中读取到每一行数据
print(line.strip())
# 写入文件
# w模式下. 如果文件不存在. 自动的创建一个文件
# w模式下. 每一次open都会清空掉文件中的内容
f = open("嫩模.txt", mode="w", encoding="utf-8")
f.write("胡辣汤")
f.close() # 每次操作之后养成好习惯.要关闭链接
# 准备一个列表.要求把列表中的每一项内容. 写入到文件中
lst = ['张无忌', "汪峰", "章子怡", "赵敏"]
f = open("打架.txt", mode="w", encoding="utf-8") # 大多数情况下要把open写循环外面
for item in lst:
f.write(item)
f.write("\n")
f.close() #养成好习惯
# a模式
f = open("打架.txt", mode="a", encoding="utf-8")
f.write("你好厉害")
# with
with open("国产自拍.txt", mode="r", encoding="utf-8") as f: # f = open()
for line in f:
print(line.strip())
# 这种代码，要写在 with里面！！！相当于：我在里面进行操作。结束后自动给你关闭
想要读取图片
在读写非文本文件的时候要加上b
with open("胡一菲.jpeg", mode="rb") as f:
for line in f:
print(line)
# 文件的复制:
# 从源文件中读取内容. 写入到新路径去
with open("胡一菲.jpeg", mode="rb") as f1, \ # \ 相当于夏宇航和这一行拼接
open("../01_初识python/胡二飞.jpeg", mode="wb") as f2:
for line in f1: # 读 f1内容，相当于：输入
f2.write(line) # 输出在 f2上
# 文件修改
# 把文件中的周 -> 张
with open("人名单.txt", mode="r", encoding="utf-8") as f1, \
open("人名单_副本.txt", mode="w", encoding="utf-8") as f2:
for line in f1:
line = line.strip() # 去掉换行
if line.startswith("周"):
line = line.replace("周", "张") # 修改 别忘了这个细节
f2.write(line)
f2.write("\n") # 又是一个细节
time.sleep(3) # 让程序休眠3秒钟
# 删除源文件
os.remove("人名单.txt")
time.sleep(3)
# 把副本文件重命名成源文件
os.rename("人名单_副本.txt", "人名单.txt")
扫一扫
评论
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
查看更多评论
添加红包
