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      常量就是不变的量

单行注释 # 
多行注释 """ """  ‘‘‘ ‘‘‘ 
被注释的内容是不是会执行的

‘‘‘ I‘m   "meet" ‘‘‘    #引号配合使用

a = ‘alex‘
b = ‘wusir‘
print(a+b)    # alexwusir  字符串拼接   注意:只能和字符串相加

a = ‘坚强‘
print(a*8)    #坚强坚强坚强坚强坚强坚强坚强坚强 字符串乘   注意:只能和数字相乘

True   真
False  假

if - 如果 在python是关键字
if True 如果是真的，告诉大家这是真的

单if
if 空格 条件 冒号
缩进 结果

print(1)
if 3>2:
    print(3)
print(2)

if else 二选一
if 空格 条件 冒号
缩进 结果
else 冒号
缩进 结果

n = input("请输入数字:")
if 3<int(n):
    print(1)
else:
    print(2)
print(6)

if elif elif 多选一或零

if 空格 条件 冒号
缩进 结果
elif 空格 条件 冒号
缩进 结果
elif 空格 条件 冒号
缩进 结果

print(110)
if 3<2: # 如果
    print("A")
elif 3>8: # 在如果
    print("B")
elif 5<0:
    print("C")
print(112)

if elif else 多选一

if 空格 条件 冒号
缩进 结果
elif 空格 条件 冒号
缩进 结果
else 冒号 
缩进 结果

if 3 == 2:
    print(1)
elif 3<2:
    print(3)
elif 3>10:
    print(4)
else:
    print(9)

if if 多选

if 空格 条件 冒号
缩进 结果
if 空格 条件 冒号
缩进 结果

if 3>2:
    print("A")
print(456)
if 3<6:
    print("B")

if嵌套

if 空格 条件 冒号
缩进 if 空格 条件 冒号
缩进 缩进 结果

sex = "女"
age = 35
if sex == "女":
    if age == 35:
		print("进来坐一坐")
    else:
        print("你去隔壁找春生")
else:
    print("你去对门找alex")


1.用户输入账号
2.用户输入密码
3.判断用户的账号是不是alex
4.如果账号是alex在继续判断密码是不是alexdsb
5.账号和密码都正确提示用户alex就是一个dsb
6.如果账号正确密码错误提示密码错误
7.如果账号错误提示账号错误


user = input("请输入账号：")
pwd = input("请输入密码：")
if user == "alex":
    if pwd == "alexdsb":
        print("alex就是一个dsb")
    else:
        print("密码错误！")
else:
    print("账号错误！")

user = input("请输入账号：")
pwd = input("请输入密码：")

# and # 和 and前边的内容为真并且and 后边的内容为真才是真

if pwd == "alexdsb" and user == "alex":
    print("alex就是一个dsb")
else:
    print("密码或账户错误！")

while 循环

while -- 关键字 (死循环)

? while 条件：

? 循环体

print(1)
while True:
    print("痒")
    print("鸡你太美")
    print("卡路里")
    print("好运来")
    print("小三")
    print("小白脸")
    print("趁早")
    print("过火")
print(2)

flag = True
while falg:
    print(1)
print(2)





 正序的示范
count = 1
while count <= 5:
     print(count)
     count = count + 1


 倒序的示范
count = 5
while count:
     print(count)
     count = count - 1


正序打印从 25 - 57
count = 25
while count <= 57:
     print(count)
     count = count + 1


倒序打印从 57 - 25
count = 57
while count >= 25:
    print(count)
    count = count - 1

break continue

while True:
    print(123)
    print(234)
    break   # 终止当前循环，break下方的代码不会进行执行
    print(345)
print(1111)

while True:
    print(123)
    print(234)
    print(345)

while True:
    print(123)
    print(234)
    continue          #continue 伪装成循环体中的最后一行代码(跳出当前循环继续下次循环)
                      #continue 下面的代码不会执行
    print(345)
print(1111)

while else

while True:
    print(111)
    break
else:
    print(222)

while True:
    print(111)
    break
print(222)

总结：

打断循环的方式：
    1.自己修改条件
    2.break
break -- 打破当前循环 （终止当前循环）
continue -- 跳出当前循环继续下次循环（将continue伪装成循环体中的最后一个行代码）
break和continue相同之处：他们以下的代码都不执行

字符串格式化

 a = "------------- info -------------"
 b = "name:"
 c = "age:"
 d = "job:"
 e = "-------------- end -------------"
 name = input("name")
 age = input("age")
 job = input("job")
 print(a + "\n" + b + name + "\n" + c + age + "\n"+ d + job + "\n" +e)

 s = """ ------------- info -------------
 name:%s
 age:%s
 job:%s
 -------------- end -------------
 """
 name = input("name")
 age = int(input("age"))
 job = input("job")
 print(s%(name,age,job))

 num = input(‘学习进度：‘)
 s11 = "大哥黑的学习进度为:%s %%"
 print(s11%(num))

 s = f"今天下雨了{input(‘>>>‘)}"
 print(s)

 s11 = "大哥黑的学习进度为:%s"
 print(s11%("不错"))

 s = f"{1}{2}{3}"
 print(s)


# %s 是占的字符串类型的位置
# %d %i是占的数字类型的位置
# %% 转义 转换成普通的%号
# 按照位置顺序传递,占位和补位必须要一一对应
#  f"{1}{2}{3}"只有python3.6以上版本可以使用

运算符

算数运算符

+
-
*
/            #python2获取的值是整数，python3获取的是浮点数（小数2.5）
例:print(5/2)
//           #(整除-- 地板除)
例:print(5 // 2)
**           #幂（次方）
例:print(3**2)
%            #模 (取余)
例:print(5 % 2)

比较运算符

>
<
==   #(等于)
!=   #(不等于)
>=
<=

赋值运算符

=        #赋值
+=       #自加
a = 10
a += 1   # a = a + 1
例:print(a)
-=       #自减
*=       #自乘
a = 10
a *= 2   # a = a * 2
例:print(a)
/=
//=
**=
%=

逻辑运算符

and    #(与/和)
or     #(或）
not    #(非）

print(bool(0))
数字中非零的都是True

? and 前后都为真的时候取and后边的

? and 前后都为假的时候取and前面的

? and 两侧一真一假取假的

print(3 and 4)                                     #4
print(0 and 4)                                     #0
print(0 and False)                                 #0
print(3 and 5 and 9 and 0 and False)               #0
print(5 and False and 9 and 0)                 #False
print(1 and 2 and 5 and 9 and 6)                   #6

? or 前后都为真的时候取or前边的? or 前后都为假的时候取or后面的? or 前后两侧一真一假取真的

print(1 or 0)                                     #1
print(1 or 2)                                     #1
print(0 or False)                                 #False
print(1 or 9 or 4 or 0 or 9)                      #1

? not True 为 False

? not False 为 True

() > not > and > or从左向右执行

print(9 and 1 or not False and 8 or 0 and 7 and False)     #1

成员运算符

? in 存在? not in 不存在

s = "alexbaoyuan"
if "bao" not in s:    
    print(True)
else:    
    print(False)       #False

编码初识

? 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

456  ----- 十进制数
0101 ----- 二进制数
除此之外还有：
十六进制  八进制  二进制

十进制转2进制：
例：将15转换成2进制
15    1

7     1

3     1

1     1
除以2取余，自下而上依次取余数，所以15的二进制数为1111

24    0

12    0

6     0

3     1

1     1

24的二进制数为11000
186     0

93      1

46      0

23      1

11      1

5       1

2       0

1       1

186的二进制数为10111010

print(bin(186))  # 十进制 -- 二进制

二进制转十进制：
10111010
自右向左计算

0*2**0 + 1*2**1 + 0*2**2 + 1*2**3 + 1*2**4 + 1*2**5 + 0*2**6 + 1*2**7=0+2+0+8+16+32+64=186

print(int("10111010",2))  # 将二进制转换成十进制

print(bool(1))  # 数字非零的就是True 零就是False

print(bool("")) # 字符串不为空就是True(有空格也是不为空) ,字符串中没有任何内容就是False

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-1
a = 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])

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)      #True

s1 = 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即切割次数为1
print(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)

s = "12.3"
print(s.isalnum())     # 判断是不是字母,数字,中文
print(s.isalpha())     # 判断是不是字母,中文
print(s.isdigit())     # 判断字符串是不是全都是阿拉伯数字
print(s.isdecimal())   # 判断是否是十进制

print(len(name))     # 计算字符串的字符数量

name =  "你好啊"
count = 0
while count < len(name):
    print(name[count])
    count += 1

# 
你
好
啊

name = 你好啊
for x in name:  # for循环
    print(x)

#
你
好
啊

for 关键字
i 是变量名
in 关键字
name 可迭代对象

错误的示范：
name = True
for i in name:
    print(i) # 数据类型中只有整型和布尔值不能够进行for循环

for i in "alex":
    pass
print(i)   # x
pass 或者 "..." 占位

列表

定义

? 列表--list--容器

? 有序,可变,支持索引.

? 列表:存储数据类型很多,字符串,数字, 布尔值,列表,集合,元祖,字典.

? 定义一个列表:

lst = ["dsb",123,True,"黑哥"]    # 用逗号分隔的是一个元素

获取对象的内存地址(id)
print(lst[0])        # dsb
print(id(lst[0]))    # 2354942210432 

lst[0] = "dsb"
print(lst)      # [‘dsb‘, 123, True, ‘黑哥‘]

s = "alex"      # 字符串是不可变数据
s = "wusir" 
s[0] = "b"
print(s)

列表的增,删,改,查

增加

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, ‘黑哥‘, ‘可‘, ‘迭‘, ‘代‘,                        ‘的‘, ‘内‘, ‘容‘]

删除

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)         # []

改

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 循环

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("123")

lst = [1,2,23,234,435,36,23,213421,421,4231,534,65]
lst.sort()  
print(lst)

lst = ["你好","我好"]
lst.sort()  
print(lst)

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 * 5
new_lst = lst * 5
print(new_lst[0] is new_lst[-5])        # True

lst = [[]]
new_lst = lst * 5
new_lst[0].append(10)
print(new_lst)
# [[10], [10], [10], [10], [10]]

lst = [1,[]]
new_lst = lst * 5
new_lst[0] = 10
print(new_lst)
# [10, [], 1, [], 1, [], 1, [], 1, []]

lst = [1,[]]
new_lst = lst * 5
new_lst[1] = 10
print(new_lst)
# [1, 10, 1, [], 1, [], 1, [], 1, []]

lst = [[]]
new_lst = lst * 5
new_lst[0].append(10)
print(new_lst)
# [[10], [10], [10], [10], [10]]

元组

定义

? 元组 -- tuple

? 有序,不可变,支持索引

? 只能索引查看和for查看,不能进行增删改

? 元组用于存储一些比较重要的信息

? 元组在配置文件中会使用

? 元组就是不可变的列表

? 定义一个元组:

tu = (1,"alex",True,"大黑哥",[1,2,3])
lst = [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]

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 - 1
for 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 = True
while flage:
    name = input("请输姓名:")  # 请输姓名:agag
    lst.append(name)          # 请输姓名:garag
    if len(lst) == 3:         # 请输姓名:garg
        flage = False         # [‘agag‘, ‘garag‘, ‘garg‘]
print(lst)  

使用 for 循环和range

lst = []
for i in range(3):
    lst.append(input("请输入姓名:"))
print(lst)
# 请输入姓名:sssht
# 请输入姓名:shtst
# 请输入姓名:hst
# [‘sssht‘, ‘shtst‘, ‘hst‘]

dic = {"常鑫":10,"李文虎":80,"张宇":100}
字典中逗号分隔叫做一个元素"常鑫"(键):10(值) -- 键值对

dic = {"常鑫":10,"李文虎":80,"张宇":100,10:"大黑哥",True:123,(1,2,3):"大煎饼",[1,2]:"meet"}
print(dic)           #报错 列表字典集合可变不能为"键"

dic = {"常鑫":10,"李文虎":80,"张宇":100}
dic["李文虎"] = 89       
print(dic)      # dic = {"常鑫":10,"李文虎":89,"张宇":100}
 # 暴力添加

dic = {"常鑫":10,"李文虎":80,"张宇":100}
dic.setdefault("大黑哥",50)      
print(dic)   # {‘常鑫‘: 10, ‘李文虎‘: 80, ‘张宇‘: 100, ‘大黑哥‘: 50}
# "大黑哥"这个键去字典查询,没有就添加,有就不执行添加.

dic = {"常鑫":10,"李文虎":80,"张宇":100}
del dic["常鑫"]
prin(dic)                # {‘李文虎‘: 80, ‘张宇‘: 100}
# 通过字典的键删除键值对

dic = {"常鑫":10,"李文虎":80,"张宇":100}
print(dic.pop("常鑫"))           # 10
print(dic)                      # {‘李文虎‘: 80, ‘张宇‘: 100}
# 通过字典的键进行删除键值对 返回值:返回的是删除的值

dic = {"常鑫":10,"李文虎":80,"张宇":100}
dic.clear()
print(dic)            #{}
# 清空

dic = {"常鑫":10,"李文虎":80,"张宇":100}
dic["常鑫"] = "dsb"
print(dic)             # {‘常鑫‘: ‘dsb‘, ‘李文虎‘: 80, ‘张宇‘: 100}
# 字典中没有某个键值对的时候就是添加,当键在字典中存在的时候就是修改
# 有则改,无则加

dic = {"常鑫":10,"李文虎":80,"张宇":100}
dic.update({"常鑫":50,"张宇":30})
print(dic)        # {‘常鑫‘: 50, ‘李文虎‘: 80, ‘张宇‘: 30}
# update括号中的字典级别高于update前面的字典

dic = {"常鑫":10,"李文虎":80,"张宇":100}
for i in dic:
    print(i)
    # 常鑫
    # 李文虎
    # 张宇
#循环获取的是字典中每个键值对的键

dic = {"常鑫":10,"李文虎":80,"张宇":100}
print(dic.get("李文虎"))     # 80
# 通过键获取值,如果将不存在字典中返回None

print(dic["ck"])            # 报错
# 通过键获取值,如果将不存在字典中报错

dic = {"1":3,"5":9,"李文虎":100}
for i in dic:
    print(i,dic.get(i))             
# 1 3
# 5 9
# 李文虎 100
# 获取字典中所有的键和值

dic = {"1":3,"5":9,"李文虎":100}
print(dic.keys())       # dict_keys([‘1‘, ‘5‘, ‘李文虎‘])
# 高仿列表 -- dict_keys([‘1‘, ‘5‘, ‘李文虎‘]) 支持for循环 不支持索引

dic = {"1":3,"5":9,"李文虎":100}
for i in dic.keys():
     print(i)                   # 1
                                # 5
                                # 李文虎
# 获取字典中所有的键

dic = {"1":3,"5":9,"李文虎":100}
lst = []
for i in dic:
    lst.append(dic[i])
print(lst)                       #[3, 9, 100]
# 获取字典中所有的值

print(list(dic.values()))        #[3, 9, 100]
# 获取字典中所有的值

dic = {"1":3,"5":9,"李文虎":100}
print(dic.items())
# dict_items([(‘1‘, 3), (‘5‘, 9), (‘李文虎‘, 100)])

dic = {"1":3,"5":9,"李文虎":100}
for i in dic.items():
    print(i[0],i[1])           # 1 3
                               # 5 9
                               # 李文虎 100

dict

定义一个字典:

print(dict(k = 1,k = 2))

随机删除:

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"] = 18
print(dic)

a,b = 10,12
print(a)
print(b)                 # 10  
                         # 12
    
    
a = 10
b = 20
a,b = b,a
print(a,b)               # 20 10
                           
a,b = [1,2]
print(a,b)               # 1 2

a,b = (3,4)
print(a,b)               # 3 4

a,_,b = (3,4,5)
print(a,b)               # 3 5  等号后边的值和前面的变量名要一一对应

a = 10,12               
print(a)                 # (10,12)  本质就是一个元组

a,b = "23"
print(a,b)               # 2 3

a,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
					     # 获取每个元素的键和值

dic = {1001:["周杰伦","林俊杰"],
       1002:{"汪峰":{"前妻1":["大烧饼"],"前妻2":["熊大","熊二"],"国际章":"肉丝"}},
       1003:{"陈冠希":["阿娇","阿萨","张柏芝"]},
       1004:{"韦小宝":[{"教主夫人":["教主"]},{"阿珂":"刺客"},{"双儿":"天地会"}, {"爱心觉罗建宁":"公主"}, {"独臂神尼":{"韦小宝师父":{"兰陵王":"隐身"},"花木兰":[ "唧唧复唧唧","木兰是战士",{"爸爸":["花和尚"]}]}}, {"陈圆圆":"丈母娘"},{"穆建平":"小郡主"}]},
       1005:{"常鑫":["大黑哥","大烧饼","吃大煎饼","肉夹馍","自行车","井盖",]}
       }

	找到"教主"
    print(dic[1004]["韦小宝"][0]["教主夫人"][0])
    找到"井盖"
    print(dic[1005]["常鑫"][-1])
    找到"熊二"
    print(dic[1002]["汪峰"]["前妻2"][-1])
    找到"隐身"
    print(dic[1004]["韦小宝"][4]["独臂神尼"]["韦小宝师父"]["兰陵王"])
    找到"花和尚"
    print(dic[1004]["韦小宝"][4]["独臂神尼"]["花木兰"][2]["爸爸"][0])

小数据池 -- 缓存机制(驻留机制)

== 判断两边内容是否相等

a = 10
b = 10
print(a == b)

is 是

a = 10
b = 10
print(a is b)  is判断基于内存地址进行判断

代码块:

? 一个文件,一个函数,一个类,一个模块,终端中每一个行是一个代码块

数字:

? 在同一代码块下 只要内容相同就采用相同的内存地址(-5以后就不是)

? 数字在做乘法的时候范围 -5 ~ 256

? 数字在做乘法的时候不能使用浮点数

字符串:

? 在同一代码块下 只要内容相同就采用相同的内存地址

? 乘法的时候总长度不能超过20

? 乘法的时候中文,特殊符号乘以1或0

布尔值:

? 在同一代码块下 只要内容相同就采用相同的内存地址

小数据池:

数字:

? -5 ~ 256

字符串:

? 在同一代码块下 只要内容相同就采用相同的内存地址

? 乘法的时候总长度不能超过20

? 乘法的时候中文,特殊符号乘以0

布尔值:

? 在同一代码块下 只要内容相同就采用相同的内存地址

? 小数据池的验证方法,必须脱离代码块才能进行验证

? 先执行代码块的规则,在执行小数据的规则 --(驻留机制)

必会:

? == 判断等号两边的值是否相等

? is 判断两边的内存地址是否相等

深浅拷贝 (复制)

? 面试必问 : 赋值,浅拷贝,深拷贝

赋值

lst = [1,2,3,[5,6,7]]
lst1 = lst
print(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()          # 新开辟一个空间给lst1

print(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] = 567
print(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] = 8
print(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 copy
lst1 = copy.deepcopy(lst)
lst[-1][-1][1] = 5
print(lst)            # [1, 2, 3, [5, 6, 7, [8, 5, 9]]]          
print(lst1)           # [1, 2, 3, [5, 6, 7, [8, 10, 9]]]

总结:

? 浅拷贝的时候只拷贝第一层元素

? 浅拷贝在修改第一层元素(不可变数据类型)的时候,拷贝出来的新列表不进行改变

? 浅拷贝在替换第一层元素(可变数据类型)的时候,拷贝出来的新列表不进行改变

? 浅拷贝在修改第一层元素中的元素(第二层)的时候,拷贝出来的新列表进行改变

? 深拷贝开辟一个容器空间(列表),不可变数据共用,可变数据数据类型(再次开辟一个新的空间),空间里的值是不可变的数据进行共用的,可变的数据类型再次开辟空间

集合 -- 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.增:

增:
s.add("67")        # 只能添加一个
print(s)
s.update("今天")    # 迭代添加
print(s)

2.删

print(s.pop())  # pop有返回值
print(s)
s.remove(3)     # 指定元素删除
print(s)
s.clear()         # 清空   -- set() 空集合
print(s)

3.改

先删再加

4.查

for i in {1,2,3}:
    print(i)

其他操作:

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)  # 父集(超集)  True
print(s1 < s2)  # 子集        False
print(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  tuple
tuple list

str转 list的方法:
name = "alex"  
print(name.split())

list转 str的方法:
lst = ["1","2","3"] 
print(‘‘.join(lst))

set - list
list - set

可变:
list ,dict ,set
不可变:
int bool str tuple
有序:
list,tuple,str,int,bool
无序:
dict,set
取值方式:
索引: str list tuple
直接: set ,int ,bool
  键: dict

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)
# {}

# 集合和字典都是迭代的时候不能改变原来的大小

name = "你好啊"

s1 = name.encode("utf-8") # 编码 

s2 = name.encode("gbk") # 编码 

s2 = s1.decode("utf-8") # 解码

print(s2.encode("gbk"))

open( )            # 打开
file               # 文件的位置(路径)
mode               # 操作文件的模式
encoding           # 文件编码方式
f                  # 文件句柄

f = open("asdf",mode="r",encoding="utf-8")
print(f.read())
f.close()

文件操作的模式:
r,w,a (重要)
rb,wb,ab (次要)
r+,w+,a+ (没啥用)

f = open("文件的路径(文件放的位置)",mode="操作文件的模式",encoding="文件的编码")       # 内置函数
f(文件句柄)

r,w,a (重要)
rb,wb,ab (次要)
r+,w+,a+ (没啥用)

r: 读文本
       read()  全部读取
       read(3) 看文件的前三个字符
       readline 读取一行(自带换行符)
       readlines() 一行一行读取存放在列表中

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:清空,写
  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 检测有文件就操作,没文件就创建