循环
while循环
count = 1 while count < 8: print("....") while True: s = input("start:") if s == "t": break #结束本次循环 if 'a' in s: print("输入内容不符合规则") continue #结束当前循环，继续执行下一次循环 print("ss:"+s) #1+2+3+4...+100? count = 1 sum = 0 while count <= 100: sum += count count +=1 print(sum) #输出1-100中的奇数 count = 1 while count <=100: if count % 2 !=0: print(count) count += 1格式化输出
name = input("输入名字：") age = input("年龄：") gender = input("xingbie:") print("%s今年%s，爱好，性bie%s"%(name,age,gender)) #%s表示占位符（任何类型） %d ：数字 %%2=%2 表示转义（%默认占位）%s就是代表字符串占位符，除此之外，还有%d, 是数字占位符， 如果把上⾯的age后⾯的换成%d，就代表你必须只 能输⼊数字啦 这时对应的数据必须是int类型. 否则程序会报错 使⽤时,需要进⾏类型转换.
基本运算符
1.算数运算符
2.比较运算符 != 和 <> 表示不等于
3.逻辑运算符 and ：并且的意思(两边都为真，结果为真) or：或者的的意思(两边有一个为真，则为真，全部是假，结果才能是假) not 非的意思(相反)
#and or not 同时存在时，先算括号，然后not，然后and，最后or
print(3>4 or 4<3 and 1==1) False print(1 < 2 and 3 < 4 or 1>2) True print(2 > 1 and 3 < 4 or 4 > 5 and 2 < 1) True print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8) False print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) False print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) False print(1 or 2) 1 print(0 or 3) 3 # x or y 如果x==0，那么就是y，否则是x print(0 and 2) 0 #and 相反 x and 如果x==0 那么就是x，否则就是y print(1 and 2) 2 4.赋值运算符
5.成员运算符
6.身份运算符
7.位运算符
一.python基本数据类型
1. int ==> 整数. 主要用来进行数学运算
2. str ==> 字符串, 可以保存少量数据并进行相应的操作
3. bool==>判断真假, True, False
4. list==> 存储大量数据.⽤用[ ]表示
5. tuple=> 元组, 不可以发⽣生改变 用( )表示
6. dict==> 字典, 保存键值对, 一样可以保存⼤大量量数据
7.set==> 集合, 保存大量数据. 不可以重复. 其实就是不保存value的dict
二. 整数(int) 在python3中所有的整数都是int类型. 但在python2中如果数据量比较⼤大. 会使用long类型. 在python3中不存在long类型
整数可以进行的操作:
bit_length(). 计算整数在内存中占⽤用的二进制码的长度
三. 布尔值(bool)
取值只有True, False. bool值没有操作
. 转换问题: str => int int(str) int => str str(int) int => bool bool(int).
0是False 非0是True
bool=>int int(bool) True是1, False是0 str => bool bool(str)
空
*字符串是False, 不空是True bool => str str(bool) 把bool值转换成相应的”值”**
四. 字符串(str)
把字符连成串. 在python中用’, “, ‘’’, “””引起来的内容被称为字符串.
五.编码
最早的计算机编码是ASCLL
1.GBK 每个字符占2个字节,16位
2.unicode 万国码 usc-2 16位 2个字节 ucs-4 32位 4个字节
3.UTF-8 每个字符最少占8位,英文占一个1字节,中文占3个字节 ,可变编码长度
4.UTF-16 每个字符最少占16位
单位转换
8bit=1byte
1024byte=1KB
1024KB=1MB
1024MB=1GB
1024GB=1TB
1024TB=1PB
1024PB=1EB
1024EB=1ZB
1024ZB=1YB
1024YB=1NB
基本数据类型(list,tuple)
列表
1.列表的介绍
列表是python的基础数据类型之⼀ ,其他编程语⾔也有类似的数据类型. 比如JS中的数 组, java中的数组等等. 它是以[ ]括起来, 每个元素⽤’ , ‘隔开⽽且可以存放各种数据类型:
lst = [1, '哈哈', "吼吼", [1,8,0,"百度"], ("我","叫", "元", "组"), "abc", {"我 叫":"dict字典"},{"我叫集合","集合"}]列表相比于字符串. 不仅可以存放不同的数据类型. ⽽且可以存放⼤量的数据. 32位 python可以存放: 536870912个元素, 64位可以存放: 1152921504606846975个元素.⽽且列 表是有序的(按照你保存的顺序),有索引, 可以切⽚⽅便取值.
2.列表的索引和切片
列表和字符串一样也拥有索引：
lst = ["麻花藤", "王剑林", "⻢芸", "周鸿医", "向华强"] print(lst[0]) # 获取第⼀个元素 print(lst[1]) print(lst[2]) lst[3] = "流动强" # 注意. 列表是可以发⽣改变的. 这⾥和字符串不⼀样 print(lst) # ['麻花藤', '王剑林', '⻢芸', '流动强', '向华强'] s0 = "向华强" s0[1] = "美" # TypeError: 'str' object does not support item assignment 不 允许改变 print(s0) 列表的切片
lst = ["麻花藤", "王剑林", "⻢芸", "周鸿医", "向华强"] print(lst[0:3]) # ['麻花藤', '王剑林', '⻢芸'] print(lst[:3]) # ['麻花藤', '王剑林', '⻢芸'] print(lst[1::2]) # ['王剑林', '周鸿医'] 也有步⻓ print(lst[2::-1]) # ['⻢芸', '王剑林', '麻花藤'] 也可以倒着取 print(lst[-1:-3:-2]) # 倒着带步⻓2.列表的增删改查
1.增，注意，list和str是不一样的。lst可以发生改变，所以就在原来的对象上进行了操作
lst = ["麻花藤", "林俊杰", "周润发", "周芷若"] print(lst) lst.append("wusir") print(lst) lst = [] while True: content = input("请输⼊你要录⼊的员⼯信息, 输⼊Q退出:") if content.upper() == 'Q': break lst.append(content) print(lst) lst = ["麻花藤", "张德忠", "孔德福"] lst.insert(1, "刘德华") # 在1的位置插⼊刘德华. 原来的元素向后移动⼀位 print(lst) # 迭代添加 lst = ["王志⽂", "张⼀⼭", "苦海⽆涯"] lst.extend(["麻花藤", "麻花不疼"]) 添加的列表 print(lst) 2.删除
pop,remove,clear,del
lst = ["麻花藤", "王剑林", "李嘉诚", "王富贵"] print(lst) deleted = lst.pop() # 删除最后⼀个,有返回值 print("被删除的", deleted) print(lst) el = lst.pop(2) # 删除2号元素 print(el) print(lst) lst.remove("麻花藤") # 删除指定元素 print(lst) # lst.remove("哈哈") # 删除不存在的元素会报错 # # print(lst) lst.clear() # 清空list print(lst) # 切⽚删除 del lst[1:3] print(lst) 3.修改
索引切片修改
# 修改 lst = ["太⽩", "太⿊", "五⾊", "银王", "⽇天"] lst[1] = "太污" # 把1号元素修改成太污 print(lst) lst[1:4:3] = ["麻花藤", "哇靠"] # 切⽚修改也OK. 如果步⻓不是1, 要注意. 元素的个 数 print(lst) lst[1:4] = ["李嘉诚个⻳⼉⼦"] # 如果切⽚没有步⻓或者步⻓是1. 则不⽤关⼼个数 print(lst) 4.查询
列表是一个可迭代对象，可以有for进行循环
for el in lst: print(el) 5.其他操作
lst = ["太⽩", "太⿊", "五⾊", "银王", "⽇天", "太⽩"] c = lst.count("太⽩") # 查询太⽩出现的次数 print(c) lst = [1, 11, 22, 2] lst.sort() # 排序. 默认升序 print(lst) lst.sort(reverse=True) # 降序 print(lst) lst = ["太⽩", "太⿊", "五⾊", "银王", "⽇天", "太⽩"] print(lst) lst.reverse() 没有返回值，显示None，对列表反向排序 print(lst) l = len(lst) # 列表的⻓度 print(l) 6.列表的嵌套
lst = [1, "太⽩", "wusir", ["⻢⻁疼", ["可⼝可乐"], "王剑林"]] # 找到wusir print(lst[2]) # 找到太⽩和wusir print(lst[1:3]) # 找到太⽩的⽩字 print(lst[1][1]) # 将wusir拿到. 然后⾸字⺟⼤写. 再扔回去 s = lst[2] s = s.capitalize() lst[2] = s print(lst) # 简写 lst[2] = lst[2].capitalize() print(lst) # 把太⽩换成太⿊ lst[1] = lst[1].replace("⽩", "⿊") print(lst) # 把⻢⻁疼换成⻢化疼 lst[3][0] = lst[3][0].replace("⻁", "化") print(lst[3][0]) lst[3][1].append("雪碧") print(lst)
元组和元组的嵌套
元组：俗称不可变的列表，又被称为只读列表，元组也是python的基本数据类型之一，
有小括号括起来，里面可以放任何数据类型的数据，查询也可以，循环也可以，
切片也可以，但就是不能改
tu = (1, "太⽩", "李⽩", "太⿊", "怎么⿊") print(tu) print(tu[0]) print(tu[2]) print(tu[2:5]) # 切⽚之后还是元组 # for循环遍历元组 for el in tu: print(el) # 尝试修改元组 # tu[1] = "⻢⻁疼" # 报错 'tuple' object does not support item assignment tu = (1, "哈哈", [], "呵呵") # tu[2] = ["fdsaf"] # 这么改不⾏ tu[2].append("麻花藤") # 可以改了. 没报错 tu[2].append("王剑林") print(tu)关于不可变，注意：这里元组不可变的意思是：子元素不可变，而子元素内部的子元素是可变的，这取决于子元素是否是可变对象
元组中如果只有一个元素，一定要添加一个逗号，否则就不是元组
tu = (1,) print(type(tu))元组也有count(), index(), len()等⽅法
1.range
range可以帮我获取一组数据，通过for循环能够获取到这些数据
for num in range(10): print(num) for num in range(1, 10, 2): print(num) for num in range(10, 1, -2): # 反着来, 和切⽚⼀样 print(num)
基本数据类型（dict）
字典（dict）是python中唯一的一个映射类型，是以{}括起来的键值对组成。在dict中key是唯一的，在保存的时候，根据key来计算出一个内存地址，然后将key-value保存在这个地址中。这种算法被称为hash算法，所以在dict中key必须是hash的。哈希所谓就是不可变的
语法
- {key1：value，key2：value}
- 注意：key必须是可哈希的，value没有要求，可以保存任意类型的数据
# 合法 dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帅 哥', '美⼥'], (1, 2, 3): '麻花藤'} print(dic[123]) print(dic[True]) print(dic['id']) print(dic['stu']) print(dic[(1, 2, 3)]) # 不合法 # dic = {[1, 2, 3]: '周杰伦'} # list是可变的. 不能作为key # dic = {{1: 2}: "哈哈哈"} # dict是可变的. 不能作为key dic = {{1, 2, 3}: '呵呵呵'} # set是可变的, 不能作为keydict保存的数据不是按照我们添加进去的顺序保存的,是按照hash表的顺序保存的,而hash表不是连续的,所以不能进行切片工作,只能通过key来获取dict 中的数据
- {key1：value，key2：value}
字典的增删改查和其他相关操作
- 增加
dic = {} dic['name'] = '周润发' # 如果dict中没有出现这个key, 就会新增⼀个key-value的组 合进dict dic['age'] = 18 print(dic) # 如果dict中没有出现过这个key-value. 可以通过setdefault设置默认值 dic.setdefault('李嘉诚') # 也可以往⾥⾯设置值. dic.setdefault("李嘉诚", "房地产") # 如果dict中已经存在了. 那么setdefault将不会 起作⽤ print(dic)- 删除
ret = dic.pop("jay") print(ret) del dic["jay"] print(dic) # 随机删除. ret = dic.popitem() # 清空字典中的所 dic.clear()- 修改
dic = {"id": 123, "name": 'sylar', "age": 18} dic1 = {"id": 456, "name": "麻花藤", "ok": "wtf"} dic.update(dic1) # 把dic1中的内容更新到dic中. 如果key重名. 则修改替换. 如果不存 在key, 则新增. print(dic) print(dic1)- 查询
print(dic['name']) # print(dic['sylar']) # 报错 print(dic.get("ok")) print(dic.get("sylar")) # None print(dic.get("sylar", "⽜B")) # ⽜B- 其他相关操作
dic = {"id": 123, "name": 'sylar', "age": 18, "ok": "科⽐"} print(dic.keys()) # dict_keys(['id', 'name', 'age', 'ok']) 不⽤管它是什么.当 成list来⽤就⾏ for key in dic.keys(): print(key) print(dic.values()) # dict_values([123, 'sylar', 18, '科⽐']) ⼀样. 也当 list来⽤ for value in dic.values(): print(value) print(dic.items()) # dict_items([('id', 123), ('name', 'sylar'), ('age', 18), ('ok', '科⽐')]) 这个东⻄也是list. 只不过list中装的是tuple for key, value in dic.items(): # ?? 这个是解构 print(key, value) 结果 123 456 True 999 id 1 name sylar age 18 stu ['帅哥', '美⼥'] (1, 2, 3) 麻花藤
# 解构
a, b = 1, 2
print(a, b)
(c, d) = 3, 4
print(c, d)
e, f = [1, 2, 3] # 解构的时候注意数量必须匹配
print(e, f)
```
- 字典的嵌套
```
# 字典的嵌套
dic1 = {
"name": "汪峰",
"age": 18,
"wife": {
"name": '章⼦怡',
"age": 28
},
"children": ['第⼀个⽑孩⼦', '第⼆个⽑孩⼦'],
"desc": '峰哥不会告我吧. 没关系. 我想上头条的'
}
print(dic1.get("wife").get("name"))
print(dic1.get("children"))
print(dic1.get("children")[1])
```万恶之源-编码
is和==的区别
- id()
通过id（）我们可以查看到一个变量表示的值内存中的地址
s = 'alex' print(id(s)) # 4326667072 s = "alex" print(id(s)) # 4326667072 lst = [1, 2, 4] print(id(lst)) # 4326685768 lst1 = [1, 2, 4] print(id(lst1)) # 4326684360 s1 = "@1 2 " s2 = "@1 2 " print(id(s1)) print(id(s2)) # 结果⼀致, 但是在终端中是不⼀致的. 所以在python中,命令⾏代码和py⽂ 件中的代码运⾏的效果可能是不⼀样的小数据池（常量池）把我们使用过的值存储在小数据池中，供其他的变量使用，小数据池给数字和字符串使用，其他数据类型不存在。
对于数字：-5~256是会被加到效数据池中的，每次使用的都是同一个对象
对于字符串：
1.如果是纯文字信息和下划线，那么这个对象会被添加到小数据池
2.如果是带有特殊字符的，那么不会添加到小数据池，每次都是新的
3.如果是带有字母*n的情况，’a’*20,在20个单位内是可以 的. 超过20个单位就不会添加 到⼩数据池中
注意(⼀般情况下): 在py⽂件中. 如果你只是单纯的定义⼀个字符串. 那么⼀般情况下都是会 被添加到⼩数据池中的. 我们可以这样认为: 在使⽤字符串的时候, python会帮我们把字符串 进⾏缓存, 在下次使⽤的时候直接指向这个字符串即可. 可以节省很多内存.
- 总结: is 比较的是地址 == 比较的是值 编码的补充
- python2中默认使⽤的是ASCII码. 所以不⽀持中⽂. 如果需要在Python2中更改编码. 需要在⽂件的开始编写:
# -*- encoding:utf-8 -*-- python3中: 内存中使⽤的是unicode码.
ASCII : 最早的编码. ⾥⾯有英⽂⼤写字⺟, ⼩写字⺟, 数字, ⼀些特殊字符. 没有中⽂, 8个01代码, 8个bit, 1个byte
GBK: 中⽂国标码, ⾥⾯包含了ASCII编码和中⽂常⽤编码. 16个bit, 2个byte
UNICODE: 万国码, ⾥⾯包含了全世界所有国家⽂字的编码. 32个bit, 4个byte, 包含了 ASCII
UTF-8: 可变⻓度的万国码. 是unicode的⼀种实现. 最⼩字符占8位
1.英⽂: 8bit 1byte
2.欧洲⽂字:16bit 2byte
3.中⽂:24bit 3byte
- 在python3的内存中. 在程序运⾏阶段. 使⽤的是unicode编码. 因为unicode是万国码. 什么内 容都可以进⾏显⽰. 那么在数据传输和存储的时候由于unicode比较浪费空间和资源. 需要把 unicode转存成UTF-8或者GBK进⾏存储. 怎么转换呢. 在python中可以把⽂字信息进⾏编码. 编码之后的内容就可以进⾏传输了. 编码之后的数据是bytes类型的数据.其实啊. 还是原来的 数据只是经过编码之后表现形式发⽣了改变⽽已.
bytes的表现形式:
1. 英⽂ b'alex' 英⽂的表现形式和字符串没什么两样 2. 中⽂ b'\xe4\xb8\xad' 这是⼀个汉字的UTF-8的bytes表现形式字符串在传输时转化成bytes=> encode(字符集)来完成
s = "alex" print(s.encode("utf-8")) # 将字符串编码成UTF-8 print(s.encode("GBK")) # 将字符串编码成GBK 结果: b'alex' b'alex' s = "中" print(s.encode("UTF-8")) # 中⽂编码成UTF-8 print(s.encode("GBK")) # 中⽂编码成GBK 结果: b'\xe4\xb8\xad' b'\xd6\xd0'英⽂编码之后的结果和源字符串⼀致. 中⽂编码之后的结果根据编码的不同. 编码结果 也不同. 我们能看到. ⼀个中⽂的UTF-8编码是3个字节. ⼀个GBK的中⽂编码是2个字节. 编码之后的类型就是bytes类型. 在⽹络传输和存储的时候我们python是保存和存储的bytes 类型. 那么在对⽅接收的时候. 也是接收的bytes类型的数据. 我们可以使⽤decode()来进⾏解 码操作. 把bytes类型的数据还原回我们熟悉的字符串:
s = "我叫李嘉诚" print(s.encode("utf-8")) # b'\xe6\x88\x91\xe5\x8f\xab\xe6\x9d\x8e\xe5\x98\x89\xe8\xaf\x9a' print(b'\xe6\x88\x91\xe5\x8f\xab\xe6\x9d\x8e\xe5\x98\x89\xe8\xaf\x9a'.decod e("utf-8")) # 解码- 编码和解码的时候都需要制定编码格式.
s = "我是⽂字" bs = s.encode("GBK") # 我们这样可以获取到GBK的⽂字 # 把GBK转换成UTF-8 # ⾸先要把GBK转换成unicode. 也就是需要解码 s = bs.decode("GBK") # 解码 # 然后需要进⾏重新编码成UTF-8 bss = s.encode("UTF-8") # 重新编码 print(bss)
