3、python基础语法知识
3.1变量
1.什么是变量？
可以变化的量
2.为什么要有变量？
程序去执行一种状态，并且是可以变化的
1.变量的使用
原则：先定义，后使用
name='hello' #定义
print(name) #使用
2.变量的内存管理
申请的变量不用就要释放
内存管理：垃圾回收机制
垃圾：没有变量名的值
引用计数：同一个值可以关联不同的变量名
引用计数增加：
x=10 #10的引用计数为1
y=x #10的引用计数为2
z=x #10的引用计数为3
引用计数减少：
x=10 #10的引用计数为1
y=x #10的引用计数为1
z=x #10的引用计数为1
del x #解除变量名x与值10的绑定关系，10的引用计数为2
del y #解除变量名y与值10的绑定关系，10的引用计数为1
z=12346 #z会解除与10的关联
print(z)
3.变量名的命名
原则：见名知意
命名规范：
变量名只能是字母，数字或者下划线的任意组合
变量名的第一个字符不能是字符
关键字不能声明为变量名
变量名的命名风格：
1.驼峰命名法
AgeOfAlex=30
2.纯小写加下划线的方法(python推荐使用这种方式)
age_of_alex=30
4.变量值
变量值的三个重要的特征
id：反映的是变量值的内存地址，内存地址不同，id不同
print(id(name))
type：数据类型
print(type(name))
value：值本身，等号右边的值
is与==
is:比较左右两个值身份id是否相等
==:比较左右两个值他们的值是否相等
注意：
值一样的情况下，id的值也不一样
id相同的情况下，值一定相同
注意：
小整数池:[-5,256]从Python解释器启动的那一刻开始，就会在内存中事先申请好一系列的内存空间来存放常用的整数
>>> m=10
>>> n=10
>>> m is n
True
>>> id(m),id(n)
(2423951786512, 2423951786512)
>>> x='aaa'
>>> y='bbb'
>>> id(x),id(y)
(2423953409264, 2423953414576)
# 垃圾回收机制
# 1.引用计数
# 1.1 直接引用
# x= 10
# print(id(x))
# 1.2 间接引用
# l=['a', x]
# print(id(l[1])) # id 地址都是相同的
# 列表在内存中开辟一个区域来存索引与内存地址，一个内存地址指向真正所存的
# x= 10
# l=['a','b', x] # l=['a的内存地址','b的内存地址','x的内存地址']
# x = 123
# x的值是变的，但是x的内存地址是不会变的
# 2.标记清除
# 循环引用
# 在循环引用的使用下，把l1,l2的直接引用去掉，没有直接访问的可能性，彼此只剩间接使用，引用计数不为0，此时他们成为了永远不能回收的垃圾，此时就叫内存泄露
l1 = [111]
l2 = [222]l1.append(l2)
# l1=['111的内存地址','l2的内存地址']
l2.append(l1)
# l2=['222的内存地址','l1的内存地址']print(id(l1))print(id(l2[0]))
# 3.分代回收
# 分代回收就是根据存活时间为变量划分不同的等级，然后对引用计数进行计算来回收
3.2常量
常量:不变的量
注意：在Python中没有常量的概念，但是在程序开发的过程中会涉及到常量的概念比如:π 一个人的年龄在某种情况下是常量
常量的表示：小写的字母全部为大写，代表常量
AGE_OF_A = 12 # 可以修改，但是最好不要修改
3.3数据类型
一、数字类型
1.整形int作用：记录年龄，身份证号码，个数等定义：age=18
2.浮点型float作用：记录薪资，身高，体重
3.数字类型的其他使用
做数学运算level = 1x = level + 1整数是可以和浮点型进行相加的
# 1.int类型
# 定义
# age = 10 # age = int(10)
# 纯数字转化为int
# int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错
# res = int('1212')
# 了解:
# 十进制=》二进制
# print(bin(20)) # 0b表示是二进制
# 二进制=》十进制
# print(int('0b1001',2))
# 十进制=》八进制
# print(oct(11)) # 0o表示八进制
# 八进制转十进制
# print(int('0o12',8))
# 十进制=》十六进制
# print(hex(12)) # 0x开头表示十六进制
# 十六进制=》十进制
# print(int('0xb',16))
# 2.浮点型float的定义
# salary=3000.3 # 本质salary=float(3000.3)
# 注意：名字+括号的意思就是调用某个功能，比如
# print(...)调用打印功能
# int(...)调用创建整型数据的功能
# float(...)调用创建浮点型数据的功能
# float同样可以用来做数据类型的转换
# s = '12.3'
# res=float(s)
# (12.3, <class 'float'>)
二、字符串类型
作用：描述类型性质的状态，比如名字，一段话
定义：用引号("",'',''' ''',""" """)包含的一串字符 延迟满足
name = 'upup'
x= 18 x是整形
x = '18' x是字符串
# 作用:定义描述性质的状态
# 定义:
# msg = 'hello'
# 类型转换:str可以把任意类型都转成字符串
# res=str({'k1':12})
# print(res,type(res)) # {'k1': 12} <class 'str'>
#单引号、双引号、多引号有什么区别呢？单双引号木有任何区别，只有下面这种情况 需要考虑单双的配合
msg = "My name is gigi , I'm 18 years old!"
#多引号什么作用呢？作用就是多行字符串必须用多引号
msg = '''
今天
天气
真好
'''
print(msg)
#数字可以进行加减乘除等运算，字符串呢？也能，但只能进行"相加"和"相乘"运算。
# name='hahaha'
# age='18'
# hahaha+age #相加其实就是简单拼接
# 'hahaha18'
# name*5
'hahaha18hahaha18hahaha18hahaha18hahaha18'
#注意1：字符串相加的效率不高
字符串1+字符串3，并不会在字符串1的基础上加字符串2，而是申请一个全新的内存空间存入字符串1和字符串3，相当字符串1与字符串3的空间被复制了一次，
#注意2：只能字符串加字符串，不能字符串加其他类型
# 内置方法
# 1.优先掌握
# 1.1 按索引取值(正向取+反向取),只能取
# 正向取
msg ='hello baby' # 空格也算字符
print(msg[3])
print(msg[6])
# 反向取
msg ='hello baby' # 空格也算字符
print(msg[-3])
print(msg[-6])
# 只能取,不能修改索引的值
msg ='hello baby' # 空格也算字符
msg[0]='H'
print(msg[0]) # 会报错
# 1.2 切片：索引的扩展应用，从一个大字符串中拷贝一个小字符串
msg ='hello baby'
res = msg[0:5] # 顾头不顾尾，从索引开始计算
print(res)
# 1.3步长
# 不写步长，默认步长为1
msg ='hello baby'
res=msg[0:5:2] # 0,2,4
print(res) # hlo
# 反向步长
msg = 'hello baby'
res = msg[5:0:-1]
print(res)
msg = 'hello baby'
res = msg[0:11]
res = msg[:] # 与上面的效果是一样的
print(res)
# 倒着取 把字符串倒着取过来
res = msg[::-1]
# 1.4长度len
msg = 'hello baby'
print(len(msg))
# 1.5成员运算 in 或者not in
# 判断一个子字符串是否存在于一个大字符串中
res='hello' in 'hello baby'
print(res)
# 1.6移除字符串左右两侧的符号strip lstrip rstrip
msg = ' hello '
res=msg.strip() # 不传参数，默认去掉空格
print(res) # 产生了新的值
msg = '***hello***'
print(msg.strip('*')) # 默认去掉*号
# 了解：strip只去两边，不去中间
msg = 'h***h**'
print(msg.strip('*'))
msg = '**/*=-**hello*-=()**'
print(msg.strip('*/-=()')) # 两边的符号可以完全去掉
#strip
name='*hahaha**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))
# 应用
uname=input('name:').strip()
upwd=input('pwd:').strip()
if uname=='hello' and upwd=='123':
print('okok')
else:
print('error')
# 1.7切分split rsplit
# 把某一个字符串按照某种分隔符进行切分，得到一个列表
info = "hello 18 baby"
res=info.split() # 不传参数默认按照空格进行分割
print(res) # 得到一个列表
# 指定分隔符
info = "hello:18baby"
res=info.split(':')
print(res)
# 指定分割次数 了解
info = "hello:18:baby"
res=info.split(':',1)
print(res)
name='a|b|c'
print(name.rsplit('|',1)) #从右开始切分
# 1.8循环 # 空格也会依次循环打印出来
info = "hello:18:baby"
for k in info:
print(k)
# 2.需要掌握
# 2.1 strip lstrip(去左边的符号) rstrip(去右边的符号)
name='*hahaha**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))
# 2.2 lower upper
msg='asdfg'
print(msg.upper())
# 2.3 startswitch endswitch 判断以什么开头与结尾的 返回的是布尔值
msg = 'hello baby'
res =msg.startswith('hello')
print(res)
# 2.4format 的三种方式
# 3.str.format 字符串格式化 兼容性好
# 按照位置传值
res = "我的名字是 {},我的年龄是 {}" .format('hello','19')
print(res)
res = "我的名字是 {0}{0}{0},我的年龄是 {1}" .format('hello','19')
print(res)
# 打破位置限制，按照key=value传值
res = "我的名字是{name},我的年纪是{age}".format(age=18,name="hello")
print(res)
# 4.f:python3.5以后才支持这种格式
x=input('name')
y=input('age')
res = f"我的名字是{x},我的年龄是{y}"
print(res)
# 2.5split(从左往右开始切) rsplit(从右往左开始切)
info = "hello:18:baby"
res=info.split(':',1)
res = info.rsplit(':',1)
print(res)
# 2.6 join 把列表拼接成字符串 可迭代对象必须都是字符串
l= ['name','12','hhhh']
res=':'.join(l) # 按照某个分隔符，把纯字符串的列表拼接成一个大字符串 注意：必须全部都是字符串
print(res)
# 2.7 replace 替换
msg = 'hello baby'
res=msg.replace('hello','hi',1) # 后面的数字表示替换几次
print(res)
# 2.8isdigit
# 判断字符串是否是由数字组成
res='123'.isdigit()
print(res)
# 3 了解
# 3.1 find rfind index rindex count
# rfind()函数用于返回字符串最后一次出现的位置(从右向左查询)，如果没有匹配项则返回“-1”。
# rindex()方法返回所在的子str被找到的最后一个索引，可选择限制搜索的字符串string[beg:end] 如果没有这样的索引存在，抛出一个异常。
msg='hello baby hhh'
res=msg.find('e') # 返回要查找的字符串在大字符串中返回的起始索引，找不到返回-1
res=msg.index('e') # 返回要找的起始索引，找不到就会抛出异常
res=msg.count('h') # 统计要返回的次数
print(res)
# 3.2 center ljust rjust zfill
msg='hello'
res = msg.center(10,'*') # 返回10个字符串，不够就用*号来补在左右两边
res = msg.rjust(10,'*') # 在右边进行填充
res = msg.ljust(10,'*') # 在左边进行填充
res=msg.zfill(10) # 用0填充，默认右填充
print(res)
# 3.3expandtabs
# expandtabs()将tab转换成空格，默认1个tab转成8个空格，\t制表符代表一个tab，我们也可以自定义转换成几个空格
msg='hello\tbaby'
res=msg.expandtabs(4) # 设置制表符代表的空格数为4
print(res)
# 3.4 capitalize swapcase title
msg = 'hello baby'
res=msg.capitalize() # 首字母大写
res = msg.swapcase() # 大小写反转
res = msg.title() # 每个单词的首字母大写
print(res)
# 3.5 is数字系列
# 3.5.1 is其他
# print('abc'.islower())
# print('abc'.isupper())
# print('hello baby'.istitle()) # 每个单词的首字母大写
# print('123m'.isalnum()) # 是否是字母或数字组成
# print('123'.isalpha()) # 是否由字母组成
# print(' '.isspace()) # 字符串由空格组成结果为True
# print('def'.isidentifier()) # 是否是由Python的内置方法
num1=b'4' # bytes
num2=u'4' # Unicode 在Python3中无需加Unicode
num3='四' # 中文数字
num4='IV' # 罗马数字
# isdigit只能识别num1，num2
#isnumberic能识别num2，num3,num4
#isdecimal 能识别num2 几乎不用
总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric
三、列表类型
索引对应值，索引从0开始，0代表第一个值
作用：按位置记录多个值，并且可以安装索引取出的值
注意：列表中存放的数据大部分都是同一个性质
定义：在[]内用逗号分隔开多个任意类型的值，一个值称之为一个元素
l = [10, 2, 'aaa', ['bbb', 'ccc'], 'ddd']
print(l)
print(l[3])
print(l[3][1]) # 列表的嵌套取值
print(l[-2][1])
# 其他的用途
student_info =[ ['Andy', 18, ['play']],
['Helen', 20, ['swim', 'sleep']]]
# 取出第二个学生的第一个爱好
print(student_info[1][2][0])
# 作用:按位置用来存多个值
# 定义:
l=[1,2,3]
print(type[l])
# 类型转换:能够被for循环遍历的类型都可以被当成参数传给list转成列表
res=list('hello')
print(res)
# 相似的还有字典
# 内置方法
# 1.优先掌握的方法
# 1.1 正向取,反向取
l=[111,'hello','haha']
print(l[0])
print(l[-1])
# 可以取也可以改
l[0]=222
# 索引存在则修改所对应的值
# 索引不存在就不能对他赋值，否则就会报错
# 往列表里面加值
print(l)
l=[111,'hello','haha']
# 追加值
l.append(333) # 这个会往列表的末尾加
# extend()一次性在列表尾部添加多个元素
l1 = ['a','b','c']
l1.extend(['a','b','c'])
['a', 'b', 'c', 'a', 'b', 'c']
# 插入值 在指定位置插入元素
l.insert(1,'wawa') # 这个是插入值 1表示按索引位置插值
print(l)
# 往列表中添加列表
l=[1,2,3]
new_l=['12','34']
l.extend(new_l)
print(l)
# 1.2切片(顾头不顾尾，步长)
l = [111,'hello','waha']
print(l[0:3])
print(l[0:5:2]) # 0 2 4
# 切完整的l列表
print(l[0:len(l)])
print(l[:])
print(l[::-1]) # 把列表给倒过来
# 切片就是copy行为，相当于浅拷贝
# new_l = l[:]
# 1.3 长度
# print(len([1,2,3]))
# 1.3成员运算in 和not in
print('aaa' in ['asd',222])
# 1.5删除
# 方式一 公用的删除，没有返回值 不支持赋值语法
l = [111,'hello','waha']
del # 删除整体
del l[1] # 删除索引为1的值
print(l)
# 方式二 列表相关的删除
# l.pop pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
# l = [111,'hello','waha']
# l.pop()# 不指定索引默认删除最后一个
# l.pop(1) # 选择删除索引为1的元素
# 方式三
# l.remove 根据元素删除 返回值是None
# l = [111,'hello','waha']
# l.remove('hello')
# 1.6循环
# for x in ['ac',222,'cv']:
# print(x)
# reverse()颠倒列表内元素顺序
l = [11,22,33,44]
l.reverse()
print(l) # [44,33,22,11]
# 1.7sort()给列表内所有元素排序
# 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
l = [11,22,3,42,7,55]
l.sort()
print(l) # [3, 7, 11, 22, 42, 55] # 默认从小到大排序
l = [11,22,3,42,7,55]
l.sort(reverse=True) # reverse用来指定是否跌倒排序，默认为False
print(l) # [55, 42, 22, 11, 7, 3]
# 1.8 了解知识：
# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
l1=[1,2,3]
l2=[2,]
print(l2 > l1) # True
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
s1='abc'
s2='az'
print(s2 > s1) # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
# True
# 所以我们也可以对下面这个列表排序
l = ['A','z','adjk','hello','hea']
l.sort()
print(l) # ['A', 'adjk', 'hea', 'hello','z']
四、字典类型dict
字典是key对应值，其中key通常为字符串类型，所以key对值有描述性
索引反应的是位置，对值没有描述的作用
作用：用来存多个值，每个值都有唯一一个key与其对应
定义：用花括号{}来表示,在括号内分开多个key:value value可以是任意类型(int float str list dict) 但是key必须是不可变类型 d = {'a':1,'b':2}
也可以这么定义字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}
# 类型转换
# 转换1:
info=dict([['name','tony'],('age',18)])
print(info) # {'age': 18, 'name': 'tony'}
# 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
res = {}.fromkeys(('name','age','sex'),None)
print(res) # {'age': None, 'sex': None, 'name': None}
# d = {'a':1, 'b':2}# print(d)
# print(type(d))
# 字典的其他用法: 嵌套取值
students_info = [
{'name1':'a', 'age1':18, 'gender':'male'},
{'name2':'b', 'age2':19, 'gender':'male'},
{'name3':'c', 'age3':30, 'gender':'male'}
]
print(students_info[1]['age2'])
# 1、按key存取值：可存可取
# 取值
dic = {
'name': 'xxx',
'age': 18,
'hobbies': ['play game', 'basketball']
}
print(dic['name']) # 'xxx'
print(dic['hobbies'][1]) # 'basketball'
# 对于赋值操作，如果key原先不存在于字典，则会新增key:value
dic['gender'] = 'male'
print(dic) # {'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
# 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
dic['name'] = 'tony'
print(dic) # {'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}
# 2、长度len
print( len(dic) ) # 3
# 3、成员运算in和not in
print('name' in dic) # 判断某个值是否是字典的key True
# 4、删除
dic.pop('name') # 通过指定字典的key来删除字典的键值对
print(dic) # {'age': 18, 'hobbies': ['play game', 'basketball']}
# 5、键keys()，值values()，键值对items()
dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 获取字典所有的key
print(dic.keys() )
dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的value
print(dic.values())
dict_values(['xxx', 18, ['play game', 'basketball']])
# 获取字典所有的键值对
print(dic.items())
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
# 6、循环
# 6.1 默认遍历的是字典的key
for key in dic:
print(key)
"""
age
hobbies
name
"""
# 6.2 只遍历key
for key in dic.keys():
print(key)
"""
age
hobbies
name
"""
# 6.3 只遍历value
for key in dic.values():
print(key)
"""
18
['play game', 'basketball']
xxx
"""
# 6.4 遍历key与value
for key in dic.items():
print(key)
"""
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')
"""
需要掌握的操作
1.get()
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
print(dic.get('k1')) # 'jason' # key存在，则获取key对应的value值
res=dic.get('xxx') # key不存在，不会报错而是默认返回None
print(res) # None
res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
print(res) # 666
# ps:字典取值建议使用get方法
2.pop()
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
v = dic.pop('k2') # 删除指定的key对应的键值对,并返回值
print(dic) # {'k1': 'jason', 'k3': 'JY'}
print( v) # 'Tony'
3.popitem()
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
item = dic.popitem() # 随机删除一组键值对,并将删除的键值放到元组内返回
print(dic) # {'k3': 'JY', 'k2': 'Tony'}
print(item) # ('k1', 'jason')
4.update()
# 用新字典更新旧字典，有则修改，无则添加
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
dic.update({'k1':'JN','k4':'xxx'})
print(dic) # {'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}
5.fromkeys()
dic = dict.fromkeys(['k1','k2','k3'],[])
print(dic) # {'k1': [], 'k2': [], 'k3': []}
6.setdefault()
# key不存在则新增键值对，并将新增的value返回
dic={'k1':111,'k2':222}
res=dic.setdefault('k3',333)
print(res) # 333
print(dic) # 字典中新增了键值对 {'k1': 111, 'k3': 333, 'k2': 222}
# key存在则不做任何修改，并返回已存在key对应的value值
dic={'k1':111,'k2':222}
res=dic.setdefault('k1',666)
print(res) # 111
print(dic) # 字典不变 {'k1': 111, 'k2': 222}
五、布尔类型bool
作用:用来记录真假这两种状态的
# 定义:
# is_ok=True
# is_ok = False
# print(type(is_ok))
x = 1
y = 0
# 1和0也可以表示状态
print(type(y))
六、集合类型
# 1.作用
# 1.1 关系运算:取交集与并集
# f1={12,23,57,89,100}
# f2={23,12,78,100}
# l=[]
# for x in f1:
# if x in f2:
# l.append(x)
# print(l)
# 1.2 去重
'''
2.定义:在花括号{}内用逗号分隔开各个元素，元素满足一下三个条件：
1，元素为不可变类型
2.集合内元素为无序
3.集合内元素没有重复
集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算
# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。
# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典
s = set() # 这才是定义空集合
'''
# 3.类型转换 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
s = set([1,2,3,4])
s1 = set((1,2,3,4))
s2 = set({'name':'jason',})
s3 = set('egon')
print(s,s1,s2,s3) # {1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}
print(set({'k1':12,'k2':29,'k3':100})) # {'k1', 'k3', 'k2'}
# 4.内置方法
# f1={12,23,57,89,100}
# f2={23,12,78,100}
# 4.1 取交集 两者共同有的
# res=f1 & f2
# print(res)
# res = f1.intersection(f2)
# print(res)
# 4.2 取并集/合集 两者都有的 重复只留一个
# res = f1 | f2
# print(res)
# print(f1.union(f2))
# 4.3 取差集 取第一个所独有的
# res=f1-f2
# print(res)
# print(f1.difference(f2))
# print(f2.difference(f1))
# 4.4 取对称差集 取两者独有的，即去掉共同有的
# 方式一:
# res=(f1-f2) | (f2-f1)
# print(res)
# 方式二:
# res=f1^f2
# print(res)
# print(f1.symmetric_difference(f2))
# 4.5 父子集:包含的关系
# f3={1,2,3}
# f4={1,2}
# print(f3>f4) # 当f1>f2时，f1为父，f2为子
# 如果 f1 = f2 的时候，f1与f2互为父子
# print(f3.issuperset(f4))
# print(f4.issubset(f3)) # f4 < f3
# 5.去重
# 5.1 只能针对不可变类型去重
# 5.2 无法保证原来的类型
# 对不需要去重，对顺序有要求的可以使用循环,既保证了顺序又去重了
l=['a','b',1,'a','a']
s=set(l) # 将列表转成了集合
print(s) # {'b', 'a', 1}
l_new=list(s) # 再将集合转回列表
print(l_new) # ['b', 'a', 1] # 去除了重复，但是打乱了顺序
# 6.其他操作
# 6.1 长度
# s={'a.txt','b','c'}
# print(len(s))
# 6.2 成员运算
# res = 'a.txt' in s
# print(res)
# 6.3 循环
# for x in s:
# print(x)
# 7 其他内置方法
# 7.1 discard 删除元素
# remove 也是删除一个元素，如果删除的元素不存在则会报错
# s={1,2,3,4,5}
# res = s.discard(1)
# res=s.discard(6)
# res = s.remove(4) # 会报错
# print(s)
# 更新 update
s={9,1,2,3,4,5}
# res=s.update({9,0})
# res=s.pop() # 去除掉第一个元素
# res=s.add(8)
# res=s.isdisjoint({3}) # 两个集合完全独立，没有共同部分，返回True
# print(res)
七、元组
作用：元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取
定义：在()内用逗号分隔开多个任意类型的值
本质：countries = ("中国"，"美国"，"英国") # 本质:countries = tuple("中国"，"美国"，"英国")
强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
countries = ("中国"，) # 本质:countries = tuple("中国")
1、数据类型转换
# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
tuple('wdad') # 结果：('w', 'd', 'a', 'd')
tuple([1,2,3]) # 结果：(1, 2, 3)
tuple({"name":"jason","age":18}) # 结果：('name', 'age')
tuple((1,2,3)) # 结果：(1, 2, 3)
tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中
2、使用
tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)
# 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！
print(tuple1[0]) # 1
print(tuple1[-2]) # 22
print(tuple1[0] = 'hehe' ) # 报错：TypeError:
# 2、切片(顾头不顾尾，步长)
print(tuple1[0:6:2] ) # (1, 15000.0, 22)
# 3、长度
print(len(tuple1) ) # 6
# 4、成员运算 in 和 not in
print('hhaha' in tuple1 )
True
print('hhaha' not in tuple1 )
False
# 5、循环
for line in tuple1:
print(line)
1
hhaha
15000.0
11
22
33
3.4与用户交互
# 接受用户的输入
# 在Python3中:input会将用户输入的所有的内存都存成字符串
username = input("请输入您的账号:")
print(username,type(username))
age = input("请输入您的年龄:")
print(age,type(age))
# age = int(age)
# int只能将纯数字的字符串转为整形# print(age,type(age))
# 在Python2中:有一个raw_input()与Python3的input一模一样
# 在Python2中的input必须要输入一个明确的数据类型
# 格式化输出
# 1.值按照位置与%s一一对应，多一个不行，少一个不行
# 缺点是要记位置，不方便
# res = "my name is %s,my age is %s"%('hello',"18")
# res = "my name is %s" % 'hello'# print(res)
# 2.以字典的形式传值，打破位置的限制
res = "我的名字是 %(name)s,我的年龄是 %(age)s" % {'age':'12','name':'hello'}
print(res)
# 注意:%s可以接受任意类型 %d只能接受int
# 3.str.format 字符串格式化 兼容性好
# 按照位置传值
res = "我的名字是 {},我的年龄是 {}" .format('hello','19')
print(res)# res = "我的名字是 {0}{0}{0},我的年龄是 {1}" .format('hello','19')
print(res)
# 打破位置限制，按照key=value传值
res = "我的名字是{name},我的年纪是{age}".format(age=18,name="hello")
print(res)
# 4.f:python3.5以后才支持这种格式
x=input('name')
y=input('age')
res = f"我的名字是{x},我的年龄是{y}"
print(res)
3.5运算符
1.算术运算符
print(1+1)
print(10 / 3) # 结果带小数
print(10 // 3) # 只保留整数部分
print(10 % 3) # 取模
2.比较运算符
返回的值是布尔值
print(10 > 3)
print(10 == 3)
print(10 <= 3)
name = input('name')
print(name=='hello')
3.赋值运算符
# 3.1增量赋值
# 年龄加1
age=18
age+=1
print(age)
# 3.2 链式赋值
x=10
y=x
z=y
x = y = z = 10 # 把上面的代码改写成这一行
# 3.3 交叉赋值
# m和n交换变量，先给一个临时变量
m=10
n=20
# temp = m
# m = n
# n = temp
# print(m)
# print(n)
m,n = n,m # 交叉赋值也可以用一行代码搞定
print(m)
print(n)
# 3.4解压赋值
# sal= [11,22,33,44,55]
# m0=sal[0]
# m1=sal[1]
# m2=sal[2]
# m3=sal[3]
# m4=sal[4]
# print(m0)
# print(m1)
# print(m2)
# print(m3)
# 更简单的做法，一行搞定 对应的变量名少一个不行，多一个不行
sal= [11,22,33,44,55]
m0,m1,m2,m3,m4,=sal
print(m0)
print(m1)
print(m2)
print(m3)
# 可以使用 *_ 来匹配所需要的值 下划线作为一个占位符
sal= [11,22,33,44,55]
x,y,z,*_=sal # 取前三个值
print(x,y,z)
*_,x,y,z=sal # 取后三个值
print(x,y,z)
x,y,*_,z # 取第一个值和第二个值，与最后一个值
print(x,y,z)
# 解压字典，默认解压出来的是字典的key
x,y,z=dict = {'a':1,'b':2,'c':3}
print(x,y,z)
字符串、字典、元组、集合类型都支持解压赋值
4.逻辑运算符
会返回布尔值True或False
# 逻辑运算:用来判断
# not :就是把紧跟其后的那个条件结果取反
print(not 10 > 6)
print(not '')
# and 逻辑与 用来连接左右两个条件 全真为真,有一个条件为假，则结果为False
# print(True and 10 > 3)
# 偷懒原则:看到一个条件为假就不用继续算下去了，直接结果为假
# or 逻辑或 用来连接左右两个条件 全假为假，如果有一个条件为真，则结果为真
print(10 > 3 or 0)
# 也有偷懒原则：看到一个条件为真，直接结果为真
# 优先级 not > and > or
# 如果单独是一串and或者or 连接，就按照从左向右的顺序依次运算即可
# 如果是混用，就需要考虑优先级了
# 3 > 4 and not 4 > 3 or 1 ==3 and 'x'=='x' or 3 > 3
res= (3>4 and (not 4 > 3)) or (1==3 and 'x'=='x') or 3 > 3
print(bool(res))
短路运算：逻辑运算的结果一旦可以确定，那么就以当前处计算到的值作为最终结果返回
短路运算面试题：
1 or 3
1
1 and 3
3
0 and 2 and 1
0
0 and 2 or 1
1
0 and 2 or 1 or 4
1
0 or False and 1
False
5.成员运算符
# 5.成员运算符
# 5.1 in 判断一个子字符串是否存在于一定大字符串 第一种更好
print('happy' in 'happy new year')
print(111 in [111,222,333]) # 列表也算
print('k1' in {'k1':111,'k2':222}) # 字典是要用key值
# 5.2 not in 判断一个子字符串是否存在于一定大字符串 逻辑同 in 但语义不明确
print('happy' not in 'happy new year')
虽然两种判断可以达到相同的效果，但我们推荐使用第二种格式，因为not in语义更加明确
# 6.身份运算符
# is 判断的是id是否相等
# 注意：==双等号比较的是value是否相等，而is比较的是id是否相等
#1. id相同，内存地址必定相同，意味着type和value必定相同
#2. value相同type肯定相同，但id可能不同,如下
3.6可变与不可变
# 可变与不可变类型
# 可变类型：值改变的情况下，id不变 证明改的是原值，原值是可以被改变的
# 不可变类型：值改变，id也改变了，证明是产生新的值，压根没有改变原值，原值是不可以被改变的
# int是不可变的类型
# float是不可变类型
# 字符串类型是不可变类型
# int float str 都被设计成了不可分割的整体，不能够被改变
# 列表 是可变类型 改变列表的值，整体是不会改变的，元素值的id会改变的
# l=['1','2','3']
# print(id(l))
# l[0]=['5']
# print(id(l))
# 字典 是可变类型 改变key的值，整体是不会改变的，元素值的id会改变的
dict = {'k1':1,'k2':2}
print(id(dict))
dict['k1']=[4]
print(id(dict))
# bool 不可变
# 什么可以当做条件？
# 1.显示布尔值
# 1.1条件可以是比较运算符
# age = 18
# print(age>18)
# 1.2条件可以是布尔值
# is_beautiful=True
# 2.隐式布尔值 所有的值都可以当做条件去使用
# 1，'aaa'
# 其中 空 0 None 为假 其余类型都为真
# abc= 1
# print(bool(abc))
3.7浅拷贝与深拷贝
# list1=['111','222','333']
# 二者分割不开，list1与list2指向的都是同一个地址
# lis2=list1 # 这个不是拷贝
# 需求:
# 1、拷贝一个原列表产生一个新的列表
# 2、想让两个列表完全独立开
# 如何copy列表
# 1.浅拷贝
# 浅拷贝：把原列表第一层内存地址完全copy一份给新列表
# list1 = [
# 'hello',
# 'bjt',
# [1,2,3]
# ]
#
# list2 = list1.copy()
# print(id(list1))
# print(id(list2))
# print(list2)
# print(list1)
# 2.深copy
# 想要copy得到的新列表和原列表的改操作完全独立开，必须要有一种可以区分可变类型与不可变类型的copy机制，这就是深copy
# 可变类型，重新开辟一个内存地址，但是内存地址里面所指的值并没有改变，全都指向原来的。不可变类型，还是用原来的地址。
import copy
list1 = [
'hello',
'bjt',
[1,2,3]
]
list2 = copy.deepcopy(list1)
# print(id(list1))
# print(id(list2))
print(id(list1[2]))
print(id(list2[2]))
# 拷贝：如果l2是l1的拷贝对象，l1内部的任何数据类型的元素变化，那么l2内部的元素也会跟着改变，因为可变类型值变id不变。
l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = l1
l1.append('g')
print(l1) # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
print(l2) # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
# 浅拷贝：如果l2是l1的浅拷贝对象，l1内的不可变元素发生了改变，l2不变；但是l1内的可变元素发生了改变，l2也会跟着改变。
import copy
l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.copy(l1)
l1.append('g')
print(l1) # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
print(l2) # ['a', 'b', 'c', ['d', 'e', 'f']]
l1[3].append('h')
print(l1) # ['a', 'b', 'c', ['d', 'e', 'f', 'h'], 'g']
print(l2) # ['a', 'b', 'c', ['d', 'e', 'f', 'h']]
# 深拷贝：如果l2是l1的深拷贝对象，那么l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1变化而变化。
import copy
l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.deepcopy(l1)
l1.append('g')
print(l1) # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
print(l2) # ['a', 'b', 'c', ['d', 'e', 'f']]
l1[3].append('h')
print(l1) # ['a', 'b', 'c', ['d', 'e', 'f', 'h'], 'g']
print(l2) # ['a', 'b', 'c', ['d', 'e', 'f']]
流程控制即控制流程，具体指控制程序的执行流程，而程序的执行流程分为三种结构：顺序结构（之前我们写的代码都是顺序结构）、分支结构（用到if判断）、循环结构（用到while与for）
3.8if判断语句
'''
完整语法：
if 条件1: # 如果条件1的结果为True，就依次执行：代码1、代码2，......
代码1
代码2
......
elif 条件2: # 如果条件2的结果为True，就依次执行：代码3、代码4，......
代码3
代码4
......
elif 条件3: # 如果条件3的结果为True，就依次执行：代码5、代码6，......
代码5
代码6
......
else: # 其它情况，就依次执行：代码7、代码8，......
代码7
代码8
'''
'''
写代码的时候要缩进四个空格
语法1：
if 条件:
代码1
代码3
代码3
'''
age = 12
name = 'abab'
if age==12 and name == 'abab' :
print('hjjjj')age = 12
print('我是其他代码')
'''
语法2:
if 条件:
代码1
代码2
代码3
else:
代码1
代码2
代码3
'''
age = 12
name = 'abab'
if age==11 and name == 'abab' :
print('我们是一样的')
else:
print('我们不一样')
'''
语法3:
if 条件:
代码1
代码2
代码3
elif 条件2:
代码1
代码2
代码3
elif 条件3:
代码1
代码2
代码3
`````
'''
score = input('请输入您的成绩:')
score=int(score)
if score >= 90:
print('优秀')
elif score >= 80:
print('良好')
elif score >= 70:
print('普通')
elif score >= 60:
print('及格')
elif score >= 0:
print('不及格')
score = input('请输入您的成绩:')
score=int(score)
if score >= 90:
print('优秀')
elif score >= 80:
print('良好')
elif score >= 70:
print('普通')
elif score >= 60:
print('及格')
else:
print('不及格')
# if 嵌套
age = 12
name = 'abab'
if age==12 and name == 'abab' :
print('我们是一样的')
is_sus=True
if is_sus:
print('happy!')
else:
print('我们不一样')
# 注意：
# 1、python用相同缩进(4个空格表示一个缩进)来标识一组代码块，同一组代码会自上而下依次运行
# 2、条件可以是任意表达式，但执行结果必须为布尔类型
# 在if判断中所有的数据类型也都会自动转换成布尔类型
# 2.1、None，0，空（空字符串，空列表，空字典等）三种情况下转换成的布尔值为False
# 2.2、其余均为True
3.9while循环语句
while循环的语法及基本使用
'''
while 条件
代码1
代码2
代码3
运行步骤：
步骤1：如果条件为真，那么依次执行：代码1、代码2、代码3、......
步骤2：执行完毕后再次判断条件,如果条件为True则再次执行：代码1、代码2、代码3、......，如果条件为False,则循环终止
'''
count = 0
while count < 5:
print(count)
count+=1
print('hhh')
print('最后一行代码')
死循环与效率问题
# 输入输出会有一定的缓存时间，不会导致致命的效率问题
# count = 0
# while count < 5:
# print(count)
#
# while True: # 1 与True都一样，但是1的效率会比True快一些
# name=input('name:')
# print(name)
# 这个死循环会带来致命的效率问题。纯计算无io的死循环会导致致命的效率问题
# while True:
# 1+1
退出循环的两种方式
# 退出循环的两种方式
# 方式一:将条件改为false,等到下次循环判断条件时才会生效
# username = 'bjt'
# yourpwd = '123'
# tag = True
# while tag:
# name = input('请输入您的账号:')
# pwd = input('请输入您的密码:')
# if name == username and pwd == yourpwd:
# print('welcom')
# tag = False
# else:
# print('Error')
# print('hhhh')
# 方式二: 可以加一个break 终止循环 只要运行到break，就会立刻终止本层循环
username = 'bjt'
yourpwd = '123'
while True:
name = input('请输入您的账号:')
pwd = input('请输入您的密码:')
if name == username and pwd == yourpwd:
print('welcom')
break
else:
print('Error')
while循环应用
# 循环的应用
# username = 'bjt'
# yourpwd = '123'
# name = input('请输入您的账号:')
# pwd = input('请输入您的密码:')
# if name == username and pwd == yourpwd:
# print('welcom')
# else:
# print('Error')
# 优化代码，重复代码不可粘贴赋值来循环使用
username = 'bjt'
yourpwd = '123'
while True:
name = input('请输入您的账号:')
pwd = input('请输入您的密码:')
if name == username and pwd == yourpwd:
print('welcom')
else:
print('Error')
while循环嵌套
# while循环嵌套
'''
每一层都必须配一个break
while True:
while True:
while True:
break
break
break
'''
username = 'bjt'
yourpwd = '123'
while True:
name = input('请输入您的账号:')
pwd = input('请输入您的密码:')
if name == username and pwd == yourpwd:
print('welcom')
while True:
cmd = input('输入命名编号:')
if cmd == 'q':
break
print('{x}正在运行中'.format(x='cmd'))
break # 后面的代码都不会执行,立刻终止本层循环
else:
print('Error')
# 改变条件的方式
username = 'bjt'
yourpwd = '123'
tag = True
while tag:
name = input('请输入您的账号:')
pwd = input('请输入您的密码:')
if name == username and pwd == yourpwd:
print('welcom')
while tag:
cmd = input('输入命名编号:')
if cmd == 'q':
tag = False
else:
print('{x}正在运行中'.format(x=cmd))
else:
print('Error')
while与continue的使用
# while 与 continue的使用 结束本次循环，直接进入下一次循环
# 强调：在continue之后加同一行代码无意义，永远无法执行
count = 0
while count < 6:
if count == 4:
count+=1
continue
print(count)
count+=1
while+else的使用
# while + else
# else 包含的代码会在while循环结束后，没有被break打断的情况下，正常结束后才会运行
# count = 0
# while count<6:
# if count == 4:
# count+=1
# continue
# print(count)
# count+=1
# else:
# print('会在while循环结束后，没有被break打断的情况下，正常结束后才会运行')
# else不会运行
# count = 0
# while count<6:
# if count == 4:
# break
# print(count)
# count+=1
# else:
# print('会在while循环结束后，没有被break打断的情况下，正常结束后才会运行')
# else 是专门针对break的
# 案例 输错三次退出程序
username = 'bjt'
yourpwd = '123'
tag = True
count = 0
while tag: # count < 3也可以
if count == 3:
print('输入次数超过三次')
break
name = input('请输入您的账号:')
pwd = input('请输入您的密码:')
if name == username and pwd == yourpwd:
print('输入正确')
else:
print('账号密码错误')
count += 1
3.10 for循环
for循环是Python提供第二种循环机制
理论上for循环能做的事情上，while循环也可以做
for循环取值比while循环更简洁
如何使用for循环
# 如何使用for循环
'''
基本语法
for 变量名 in 可迭代对象:
代码1
代码2
代码3
···
可迭代对象可以是列表，字典，字符串，元组，集合
'''
**案例：**
```Python
# 案例 列表循环取值
# l=['aa','22','333']
# for x in l:
# print(x)
# l=['aa','22','333']
# i=0
# while i < 3:
# print(l[i])
# i+=1
# 字典循环取值
# dict = {'k1':11,'k2':22,'k3':33}
# for x in dict:
# print(x,dict[x])
# 字符串取值 空格也算
msg = 'have a good time'
for x in msg:
print(x)
总结for循环与while循环
# 总结 for 循环 与 while 循环
# 相同之处：都是循环，for循环能做的事，while循环也能做
# 不同之处：while循环称之为条件循环，循环次数取决于条件什么时候变为假
# for循环称之为取值循环，循环次数取决于in后面包含的值的个数
for循环:range()控制循环次数
# for循环控制循环次数:range()
# 有局限性
# for x in '1 2':
# print('循环我')# 会循环3次，空格也算
# range()功能介绍
'''
顾头不顾尾
range(10)
[0,1,2,3,4,5,6,7,8,9]
range(1,9)
[1,2,3,4,5,6,7,8]
range(1,9,1)
[1,2,3,4,5,6,7,8]
range(1,9,2)
[1,3,5,7]
'''
# for i in range(3):
# print('循环3次')
# for i in range(10):
# print('循环3次')
username = 'bjt'
yourpwd = '123'
for i in range(3):
name = input('请输入您的账号:')
pwd = input('请输入您的密码:')
if name==username and pwd == yourpwd:
print('输入正确')
break
else:
print('密码错误')
continue
print('错误次数超过三次')
# range()补充知识
# 1.可以按照索引取值 for循环可以按照range()索引取值，但是有点麻烦，不推荐
l = ['a','b','c','d']
for k in range(len(l)):
print(k,l[k])
# 2.range()在Python3里面得到的是一只会下鸡蛋的老母鸡
for i in range(10):
print(i)
for + continue
# for + continue
for i in range(6):
if i == 4:
continue
print(i)
for 循环嵌套
# for循环嵌套 外层循环执行一次，内层循环要全部执行玩
for i in range(3):
print('外层循环=====')
for j in range(5):
print('内层循环')
# 跳出for循环，只有break。结束本次，进入下一次只有continue
补充print()
# 补充：print()
# print()可以传多个值，逗号会表现为空格号 print()打印会自带一个换行符
print('hello\n',end='')
print('hi')
print('hello',end='')
print('hi')
