python学习笔记

#  %格式化输出
'''
name='czxh'
age=18
print("我的姓名：%s 我的年龄：%06d" % (name,age))
'''
'''
s=4.3
print("%.6f"%s)#设置小数点位数
'''


#  f格式化输出
'''
print(f"我的名字是{name},年龄是{age}")

'''
'''
format方法是Python中用于字符串格式化的内置方法，它允许你将指定的值插入到字符串的占位符中。‌
基本用法

    ‌插入变量‌：在字符串中使用“{}”包围变量名，然后在format函数中列出变量和对应的值。例如："The value is: {}".format(100) 输出为 "The value is: 100"。‌1
    ‌指定位置‌：在格式字符串中的“{}”里可以使用数字指定变量的位置。例如："{} and {}".format("apple", "banana") 输出为 "apple and banana"。‌1
    ‌格式化数据类型‌：在“{}”内可以使用特定的格式代码来指定数据的显示方式。例如："{:05d}".format(123) 表示用至少五位数字显示整数，不足的前面用零填充；"{:.2f}".format(3.14159) 表示显示浮点数并保留两位小数。

高级用法

    ‌复杂应用‌：format方法支持更复杂的操作，如条件判断和循环，使得字符串的输出更加灵活多变。例如，可以在format中嵌入if语句，根据条件改变输出内容。
    ‌指定长度格式化‌：多用于学校课后作业以及面试题，日常工作较少使用。例如："{} {} {} {}".format("Hello", "Hello", "Hello", "Hello") 输出为四个"Hello"分行显示。‌2

示例

    ‌格式化数字‌：num = 123; print("{:05d}".format(num)) 输出为 "00123"。
    ‌控制浮点数精度‌：float_num = 3.14159; print("{:.2f}".format(float_num)) 输出为 "3.14"。
    ‌使用条件判断‌："温度是{:}{}".format(temp_sign)，当温度为正时，temp_sign为空字符串，否则为“负”。

通过合理使用format方法，可以根据需要精确地控制字符串的输出格式，使代码更加简洁和易于理解。
'''


#算术运算符(使用算术运算符，只要其中有浮点数，结果就用浮点数表示)
#    // 取整除，向下取整，（只要有小数，则忽略）
'''
print(7//2)
'''
#   % 取余数（取模）
'''
print(5%2)
'''
#   **  幂    m**n  m的n次方
'''
print(7**2)
'''
#赋值运算符
'''
num1=5
num2=8
num3=num1
num4=num1+num2
print(num1)
print(num4)


a=1
a=a+1
a+=1   #a+=1 等价于 a=a+1
a
'''

#转义字符
'''
\t  制表符
\n  换行——将当前位置移动到下一行开头
\r  回车——将当前位置移动到本行开头
\\  输出 \

r 原生字符串，默认不转义！
print(r"\r\n\t")   

'''


#if 判断
'''
if 5:
    print("haha1111")
'''

#逻辑运算符  and   or   not
'''
a='haha'
b='heihei'
if a=='haha' and b=='heihei':  #左右两边都符合为真
    print('666666666')


if a=='haha' or b=='666':
    print('777777777') #有一边为真则为真

print(3<9)#返回True
print(not 3<9)#返回False    #  not 表示相反的结果


'''


#基本格式
'''
if 1:
    print("11111")
else:
    print("222222")
'''
#if_elif_else格式
'''
if 1==2:
    print("1111111")
elif 1==3:
    print("222222")
elif 1==1:
    print("55555")
else:
   print("00000")
'''

# 三目运算：
# 格式：       为真结果 if 条件 else 为假结果

#循环
'''
i=1
while i<=5:
    print("1111")
    i+=1
# 死循环
while True:
    print("1")
'''

#while循环计算1+2+3……+100
'''
s=0
out=0
while s<=100:
    out+=s
    s+=1
print(out)
'''

# for循环——也叫做迭代循环
#格式如下：
'''
for 临时变量 in 可迭代对象:
    循环满足条件执行的代码

'''
#可迭代对象就是要去遍历取值的整体，字符串是可迭代对象,能被for循环遍历取值
'''

s='helloworld'
for i in s:
    print(i)

'''

# range()函数用来记录循环次数，相当于计数器
# range()里面有三个参数，分别为start,end,step
'''
for i in range(1,6):
    print(i)
'''# range 的 （   ） 遵循包前不包后原则，以上输出为1，2，3，4，5，类似于数学中的区间  [    )
'''
for i in range(5):
    print(i)
'''#如果只写一个数，默认为循环次数，从0开始循环。以上输出为0，1，2，3，4


# 例题：利用for循环计算1+2+3……+100
'''
a=1
b=0
for i in range(1,101):
    b+=a
    a+=1
print(b)
'''

#  break 和  continue
'''
break: 结束循环
continue: 结束本次循环，进入下一次循环//////continue使用前注意修改计数器，否则会陷入死循环
注：只能放到循环里面
'''

# 字符串编码-（本质上是二进制与语言文字的一一对应关系）
'''
Unicode：所有字符都是2个字节
优点：字符与数字之间的转换速度快
缺点：占用空间大

UTF-8: 对不同的字符用不同的长度表示
优点：节省空间
缺点：字符与数字的转换速度慢，每次都要计算字符要用多少个字节来表示



'''



#字符串编码转换
'''
1.编码：  encode()
    将其他编码的字符串转换成Unicode编码
2.解码：  decode()
    将Unicode编码的字符串转换成其他编码的字符串
'''
'''
a = 'hello'
print(type(a))#打印数据类型，输出<class 'str'>，字符串类型
a1 = a.encode()#进行编码
print(a1)#打印a1,输出 b'hello'
print(type(a1))#打印数据类型，输出<class 'bytes'>，以字节为单位进行处理
a2 = a1.decode()#解码
print(a2,type(a2))#输出 hello <class 'str'>
'''
'''
s='hello world!!!'
s1=s.encode("utf-8")
print(s1,type(s1))
s2=s1.decode("utf-8")
print(s2,type(s2))
'''
'''
b'hello world!!!' <class 'bytes'>
hello world!!! <class 'str'>
'''

#字符串运算符

# ‘+’ 字符串拼接
'''
print("10"+"10")    # 输出 1010
'''

# ‘*’ 字符串重复输出
'''
print("hello"*5)    # 输出 hellohellohellohellohello（需要多少次，*后面写多少）
'''



# 成员运算符（作用：检查字符串中是否包含某个子字符串）
'''
in :如果包含，返回True,不包含返回False
not in :包含返回False,不包含返回True
'''
'''
name='helloworld'
print('e' in name)  #返回True
print('i' in name)  #返回False
print('e' not in name)  #返回False
print('i' not in name)  #返回True
print('ell' in name)    #返回True
print('ell' not in name)    #返回False
'''


#下标（索引）
'python中从左往右数，下标从0开始！！！！！！！！！！！！！！！'
'作用：通过下标能快速找到对应的数据！'
'   格式：字符串名[下标值]  '

'''
name='six'
print(name[0])      #输出s
print(name[1])      #输出i
print(name[2])      #输出x
#print(name[3])      #超出范围，报错！
'''

'下标从右往左数，从-1开始！！！'
'''
print(name[-1],name[-2],name[-3])   #输出x i s
'''


#切片：对操作的对象截取一部分的操作
'''
#       语法：     [开始位置:结束未知:步长]
#       包前不包后原则！！

s='abcdefghigklmn'
print(s[0:4])   #输出abcd
print(s[3:6])   #输出def
print(s[3:])    #输出defghigklmn    表示下标3之后的全部截取
print(s[:6])    #输出abcdef         表示下标7之前的全部截取

print(s[-1:])   #n
print(s[:-1])   #abcdefghigklm
#步长的绝对值大小决定切取的间隔，正负号表示切取方向，正数表示从左往右切，负数表示从右往左切,不写步长默认是1

print(s[-1::1]) #输出n  表示的是从下标为-1的数从左往右切，只有s[-1]一个值
print(s[-1:-5:-1])  #nmlk   表示从下标-1的数从右往左切，切到-5停止，不包含-5

print(s[0:7:2]) #aceg   表示从左往右切片，每2个间隔取一次
'''


#字符串常见操作

#1.查找元素：
# find() 检测某个子字符串是否包含在字符串中，如果在就返回这个子字符串开始位置的下标，否则返回-1
# 格式：  find(子字符串，开始位置下标，结束位置下标)  开始和结束位置下标可以省略，表示在整个字符串中查找
'''
name='bingbingbangbang'
print(name.find('b'))   #输出0，检测到bing
print(name.find('b',4)) #输出4，表示从下标4向后开始查找
print(name.find('bing',4,10))   #输出4，表示从下标4到10查找‘bing’
'''


#2.index()  检测某个子字符串是否包含在字符串中，如果在就返回这个子字符串开始位置的下标，否则报错！
#格式       index(子字符串，开始位置下标，结束位置下标)     开始和结束位置下标可以省略，表示在整个字符串中查找
#和find的区别：find没有找到返回-1，index则会报错！
'''
n='hahayou'
#print(n.index('h',4))   #没有找到，会报错！
print(n.index('ha'))    #0 
'''

#3.count()  返回某个子字符串在整个字符串中出现的次数，没有则返回0
'''
s='冰冰邦邦！'
print(s.count('冰'))    #输出2，‘冰’出现过两次！
print(s.count('冰',1))  #输出1，从1往后找‘冰’出现过1次！
'''


#判断
#   startswith()    是否以某个字符串开头，是返回Ture，否则返回False，如果设置开始和结束位置下标，则在指定范围内查找
'''
s='heloworld'
print(s.startswith('he'))   #返回True
print(s.startswith('wor',4))   #返回True
print(s.startswith('he',1))     #返回False
'''
#   endswith()  是否以某个字符串结束，是返回Ture，否则返回False，如果设置开始和结束位置下标，则在指定范围内查找
'''
s='heloworld'
print(s.endswith('ld'))     #返回True
print(s.endswith('h'))      #返回False
'''
#   isupper()   字母是否全为大写，是返回Ture，否则返回False，如果设置开始和结束位置下标，则在指定范围内查找


#   修改元素
# 1. replace()  替换    格式：replace(旧内容，新内容，替换次数)，替换次数可以省略，默认全部替换
'''
name='hahaha'
print(name.replace('ha','1'))   #输出111
print(name.replace('ha','1',1)) #输出1haha  只替换1次
'''

#   split() 指定分隔符来切割字符串，以列表的形式返回，如果字符串中不包含分割内容，就不进行分割，会作为一个整体
'''
name='ha,ha,ha'
print(name.split(','))  #输出 ['ha', 'ha', 'ha'] 按‘,’分割
print(name.split('a'))  #输出 ['h', ',h', ',h', ''] 按a分割
print(name.split(',',1))    #输出['ha', 'ha,ha'] 指定只分割一次！
'''
#   capitalize(): 第一个字符大写，其他都小写
'''
print('bingBingBangbang'.capitalize())  #返回 Bingbingbangbang
'''
#   lower()  大写字母转为小写
'''
print("BINGBINGBANGBANG".lower())   #返回bingbingbangbang
'''
#  upper()  小写字母转大写
'''
print("bingbingbangbang".upper()) #返回BINGBINGBANGBANG
'''



#     列表
'''
定义：是处理一组有序项目的数据结构
格式：列表名=[元素1，元素2，元素3……]
注意：列表中所有元素放在[]中，并使用逗号隔开，一个列表中的数据类型可以不同

'''
'''
li=[1,2,3,4]
print(type(li))     # <class 'list'>
'''
'''
列表可以进行切片操作
'''
'''
print(li[0:3])      # [1, 2, 3]
'''
'列表也是可迭代对象，可以for循环遍历取值'
'''
for i in li:
    print(i)
'''
'''
输出
1
2
3
4
'''


# 列表常见操作
# 1.添加元素
#    append()整体添加   extend()分散添加，将另外一个类型中的元素逐一添加,只能添加可迭代对象    insert()在指定位置插入元素，原来该位置的元素会后移
'''
li=[1,2,3,4]
li.append("four")
print(li)   # 输出 [1, 2, 3, 4, 'four']

li.extend('six')
print(li)   # 输出 [1, 2, 3, 4, 'four', 's', 'i', 'x']

li.insert(3,'ten')
print(li)   # 输出 [1, 2, 3, 'ten', 4, 'four', 's', 'i', 'x']

'''




#修改元素
#直接通过下标就可以进行修改
'''
li=[1,2,3,4]
print(li[1])    #输出2
li[1]='ha'
print(li[1])    #输出ha
'''


#查找元素
# in       not in   和字符串中的用法一样
'''
l=[1,2,3]
print(1 in l)   #返回True
print(1 not in l)   #返回False
'''

#实例：(检测用户输入昵称是否存在)
'''
name_list=['my3171','qwer','bingbingbangbang','Y&Y','我真的害怕极了']
while True:
    name=input("请输入您的昵称！")
    if name in name_list:
        print(f"昵称{name}已被占用！")
    else:
        name_list.append(name) #把新的昵称放入列表
        print(f"成功注册昵称{name}！")
        print(name_list)
        break
'''


# index 返回指定数据所在位置的下标，如果查找的数据不存在就会报错
# count 统计指定数据在当前列表出现的次数
# 跟字符串用法相同









#删除列表元素
# del
'''
li=['a','b','c','d']
#del li      #删除整个列表
#print(li)   #报错，因为列表已经被删除！

del li[2]
print(li)   #['a', 'b', 'd']    根据下标删除
'''




# pop
#删除指定下标的数据，不写下标python3版本会默认删除最后一个元素！
'''
l=[1,2,3,4]
l.pop()
print(l)    #[1, 2, 3]
l.pop(2)
print(l)    #[1, 2] 指定下标删除，超出下标范围则报错！
'''


#remove
#根据元素的值进行删除
'''
li=[1,2,3,'a','b','c','bbbb']
li.remove('a')
print(li)   #[1, 2, 3, 'b', 'c', 'bbbb']
li.remove(2)
print(li)   #[1, 3, 'b', 'c', 'bbbb']

#如果有重复的元素，默认删除最开始出现的元素
'''



#   列表排序
#   sort():将列表按照特定顺序重新排列，默认从小到大
#   reverse():倒序，将列表倒置过来
'''
li=[1,5,2,7,4,3,0,9,8]
li.sort()
print(li)   #[0, 1, 2, 3, 4, 5, 7, 8, 9]


li.reverse()
print(li)   #[9, 8, 7, 5, 4, 3, 2, 1, 0]
'''


#【重点】【列表推导式】
#格式：     [表达式 for 变量 in 列表]  或  [表达式 for 变量 in 列表 if 条件]
# in 后面不仅仅可以放列表，还可以放range()函数，可迭代对象
'''
li=[1,2,3,4]
[print(i) for i in li]      #输出1 2 3 4

li=[]
[li.append(i) for i in range(0,9)]
print(li)       # 输出[0, 1, 2, 3, 4, 5, 6, 7, 8]


#把奇数放进列表
li=[]
[li.append(i) for i in range(0,9) if(i%2!=0)]
print(li)       # 输出[1, 3, 5, 7]

#把1-50的偶数放进列表
li=[]
[li.append(i) for i in range(1,51) if(i%2==0)]
print(li)       # 输出[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50]
'''


#列表嵌套————一个列表里面又有列表
'''
li=[1,2,3,[4,5,6],7,8,9]    #[4,5,6]是内层列表
print(li[3])    # 输出[4, 5, 6]   取出里面的列表
print(li[3][0]) # 输出4     取出内列表中的元素

'''






# 元组
'''
格式：元组名=(元素1,元素2,元素3)
注意：所有元素放在()中，并使用逗号隔开，一个元组中的数据类型可以不同,元组中只有一个元素的时候，末尾必须加上逗号！！！！
应用场景：
    1.  函数的参数和返回值  
    2.  %格式化输出后面的()本质上是一个元组
    3.  数据不可以被修改，保护数据的安全
'''
'''
t=(1,2,3,4)
print(type(t))  # <class 'tuple'>
tua=() #定义空元组
tp=(1,) #定义只有一个元素的元组
print(t[2]) #输出3
print(len(t))   #输出4
'''
#注意：元组只能支持查询操作，不支持进行增加，删除，修改的操作！！！  （与列表的区别），元组可以使用count(),index(),len()

#元组可以进行切片操作！！！
'''
print(t[2:])    #输出(3, 4)
'''

#字典
#格式： dic={'name':'my3171','age':'18'}     
#通过键值对的形式进行保存，键和值之间用冒号隔开，键值对之间用逗号隔开，
#键具有唯一性，但值可以重复
#格式： 字典名={键1:值1,键2:值2,键3:值3，键4:值4}
'''
dic={'name':'my3171','age':'18'}
print(type(dic))    # <class 'dict'>
'''

#键名具有唯一性，如果键名重复，不会报错，但前面的值会被后面的值覆盖
'''
dic={'name':"111","name":"222"}
print(dic)  # 输出{'name': '222'}
'''





#【字典的常见操作】
#1.查找元素(字典中没有下标，查找元素需要根据键名！！！！)
'''
1.      变量名[键名]        若键名不存在则报错
2.      变量名.get(键名)    若键名不存在则返回None,或者自定义返回内容
'''
'''
dic={'name':3171,'age':18}
print(dic['age'])   #输出 18
print(dic.get('name'))  #输出 3171
print(dic.get('haha'))  #输出 None
print(dic.get('haha','不存在')) #输出 不存在
'''

#2.修改元素(字典通过键名修改)
#格式： 变量名[键名]=值
'''
dic={'name':3171,'age':18}
dic['age']=20
print(dic)  #输出 {'name': 3171, 'age': 20}
'''

#3.添加元素
#格式： 变量名[键名]=值     （注意：键名存在就修改，不存在就新增！！！！）
'''
dic={'name':3171,'age':18}
dic['tel']='1333333'
print(dic)  #输出 {'name': 3171, 'age': 18, 'tel': '1333333'}
'''

#4.删除元素
# del
# 删除整个字典： del 字典名
# 删除指定的键值对，键名不存在就会报错：   del 字典名[键名]
'''
dic={'name': 3171, 'age': 18, 'tel': '1333333'}
del dic['tel']
print(dic)  #输出 {'name': 3171, 'age': 18}
'''


# clear 清空整个字典里的内容，但保留这个字典
'''
dic={'name': 3171, 'age': 18, 'tel': '1333333'}
dic.clear()
print(dic)  #输出 {}
'''

# pop 删除指定键值对，键不存在就会报错，不写键名也报错
'''
dic={'name': 3171, 'age': 18, 'tel': '1333333'}
dic.pop('tel')
print(dic)  #输出 {'name': 3171, 'age': 18}
'''

# popitem() 3.7之前的版本是随机删除一个键值对，3.7之后是默认删除最后一个键值对




# 字典常见操作

# 求长度    len()
# 返回字典里面包含的所有键名    keys()
# 返回字典里面包含的所有值    values()
# 返回字典里面包含的所有键值对(元组形式)    items()
'''
dic={'name': 3171, 'age': 18, 'tel': '1333333'}
print(len(dic))     # 输出 3    （字典中有3个键值对）
print(dic.keys())   # 输出 dict_keys(['name', 'age', 'tel'])
print(dic.values()) # 输出 dict_values([3171, 18, '1333333'])
print(dic.items())  # 输出 dict_items([('name', 3171), ('age', 18), ('tel', '1333333')])
'''
'''
for i in dic.keys():
    print(i)        #只取出键名
'''
'''
name
age
tel
'''
'''
for i in dic.values():
    print(i)        #只取出值
'''
'''
3171
18
1333333
'''
'''
for i in dic.items():
    print(i)        #取出键值对(元组形式)
'''
'''
('name', 3171)
('age', 18)
('tel', '1333333')
'''


# 集合
# 格式：    s={1,2,3}
# 注意：    1. 集合是无序的，里面的元素是唯一的     2. 可以用于元组或列表去重
'''
s={1,2,3}
print(type(s))      # 输出 <class 'set'>
print(s)            # 输出 {1, 2, 3}
# 注意： s={}是定义空字典，如果要定义空集合，则用：     s=set()
s=set()
print(type(s))      # 输出 <class 'set'>
#集合具有无序性：
s1={'a','b','c','d','e','f'}
s2={1,2,3,4,5,6}
print(s1)  #每次运行结果都不同
print(s2)   #每次运行结果相同，都是{1, 2, 3, 4, 5, 6}
#出现这种现象的原因是    集合元素无序性的实现方式涉及到hash表
print(hash('a')) #每次运行结果都不同，哈希值不同，在哈希表中的位置不同，这就实现了集合的无序性
print(hash(1)) #每次运行结果都是1，python中int整形的哈希值就是它本身，在哈希表中的位置不会发生变换

# 无序性：不能修改集合中的值


#集合具有唯一性，可以自动去重
s={1,2,1,3,4,4,5,2}
print(s) #输出 {1, 2, 3, 4, 5}
'''



#集合常见操作：
'''
add()   添加的是一个整体
update()    把传入的元素拆分，个个放入集合中
remove()    选择数字有就删除，没有就报错
pop()   进行无序排列，然后将左边第一个元素删除
discard()   选择元素删除，没有不进行任何操作

'''

# add() 添加的是一个整体
'''
s2={1,2,3,4}
print("原集合：",s2)
s2.add(5)
print("现集合：",s2)
# 注意：由于集合具有唯一性，如果需要添加的元素在原集合中已经存在，就不会进行任何操作
s2.add(1)
print(s2)  #输出{1, 2, 3, 4, 5} 并没有多添加一个1
# 注意：一次只能添加一个元素
'''

# update 把传入的元素拆分，个个放入集合中
# update 里面只能放入能被for循环取值的可迭代对象（字符串，列表，元组）
'''
s2={1,2,3,4}
s2.update('567')
print(s2)  # {1, 2, 3, 4, '5', '7', '6'}
s2.update([7,8,9])
print(s2)  # {1, 2, 3, 4, '5', 7, '6', 8, 9, '7'}
s2.update((33,44,55,66))
print(s2)  # {'5', 1, 2, 3, 4, 33, 66, 7, 8, 9, 44, '6', 55, '7'}
'''

# remove 选择删除的元素，如果集合中有就删除，没有则报错
'''
s={1,2,3,4}
s.remove(3)
print(s) # {1, 2, 4}
'''

# pop 里面不需要填任何东西，默认直接是删除集合根据哈希表排序后的第一个元素
'''
s={1,2,3,4} # 数字是有序的，删除第一个，字符串无序……
s.pop()
print(s)
'''

# discard 选择要删除的元素，有就会删除，没有则不会进行任何操作(区分remove)
'''
s={1,2,3,4}
print("原集合：",s)
s.discard(3)
print(s) # {1, 2, 4}
'''



# 交集，并集
# 交集 &
'''
s1={1,2,3,4}
s2={3,4,5,6}
print(s1 & s2)  # {3, 4}
# 若没有交集，返回的是空集合 set()
s3={'a','v','t'}
s4={'a','p','t'}
print(s3 & s4) # {'a', 't'}
'''


# 并集 |
'''
a1={1,2,3,4}
a2={5,6,7,8}
print(a1 | a2) # {1, 2, 3, 4, 5, 6, 7, 8}
# 由于集合的唯一性，所以重复的元素不会多出
s3={1,2,3,4}
s4={3,4,7,8}
print(s3 | s4) # {1, 2, 3, 4, 7, 8}
'''






# 类型转换
'''
常用的类型转换语句：
int(x)      将x转换成一个整数
float(x)    将x转换成一个浮点数
str(x)      将对象x转换成字符串
eval(str)   用来计算在字符串中的有效python表达式，并返回一个对象
tuple(s)    将序列s转换成一个元组
list(s)     将序列s转换成一个列表
chr(x)      将一个整数转换成一个字符
'''

# int()
'''
# 1.强制转换数字类型，将纯数字组成的字符串转换成整形数字，如果字符串中有数字和正负号以外的字符，则会报错
s='1'
print(type(s))          # <class 'str'>
print(type(int(s)))     # <class 'int'>
# 2.浮点型转整形(会丢失小数点后的部分，只保留整数部分)
s=12.5
print(type(s))          # <class 'float'>
print(type(int(s)))     # <class 'int'>
print(int(s))           # 12
s=0.1
print(type(s),type(int(s)),s,int(s))    # <class 'float'> <class 'int'> 0.1 0
'''


# float()
'''
# 整形转换成浮点型，会自动添加一位小数,如果字符串中有数字,小数点和正负号以外的字符，则会报错
print(float(11))    # 11.0
print(float(-11))   # -11.0
'''

# str()
'''
# 将对象转换成字符串类型，任何类型都可以转换成字符串类型！
print(str(100),type(str(100)))  # 100 <class 'str'>
print(str([1,2,3]),type(str([1,2,3])))  # [1, 2, 3] <class 'str'>
# 注意：浮点型转换成字符串型会去除末位为0的小数部分
print(str(11.30))   # 11.3
'''



# eval()
'''
# 用来计算在字符串中的有效python表达式，并返回一个对象
print(eval("10+10"))    # 20
eval("print('111')")    # 111
# 注意：eval只能用于计算单行表达式，如果需要多行，应该用 exec()

# eval 可以实现list,dict,tuple,str之间的转换
s="[[1,2],[3,4],[5,6]]"
print(s,type(s))        # [[1,2],[3,4],[5,6]] <class 'str'>
s1=eval(s)
print(s1,type(s1))      # [[1, 2], [3, 4], [5, 6]] <class 'list'>

a1="{'name':'bing','age':18}"
print(a1,type(a1))
a2=eval(a1)             # {'name':'bing','age':18} <class 'str'>
print(a2,type(a2))      # {'name': 'bing', 'age': 18} <class 'dict'>

# 注意：eval 非常强大，但是不够安全，容易被恶意修改
'''





# list() 将可迭代对象转换成列表，不是则报错
'''
# 支持转换成list的类型：str,tuple,dict,set
print(list("abcde"))    # ['a', 'b', 'c', 'd', 'e']
print(list((1,2,3,4)))  # [1, 2, 3, 4]
print(list({'name':'bing','age':18}))   # ['name', 'age']
# 注意：字典转列表，只取键名
print(list({1,2,3,4}))  # [1, 2, 3, 4]
print(list({'a','b','c','c'}))  # ['a', 'c', 'b']
# 注意：集合转列表，先去重，字符串也是随机性的

'''



# 深浅拷贝————只针对可变对象！！！！！！！

# 深拷贝：外层对象和内部元素都拷贝了一遍

# 赋值（数据完全共享）
'''
# 会随着原对象一起变量
li=[1,2,3,4]
print(li)
li2=li  # 直接将li赋值给li2
print(li,li2)   # [1, 2, 3, 4] [1, 2, 3, 4]
li.append(6)
print(li,li2)   # [1, 2, 3, 4, 6] [1, 2, 3, 4, 6]
# 发现两个列表都发生了变化！！
# 赋值相等于完全共享资源，一个值的改变会完全被另一个值共享
print("li内存地址：",id(li))
print("li2内存地址：",id(li2))
# 发现内存地址相同！！！
'''



# 浅拷贝（数据半共享）
'''
# 会创建新的对象，拷贝第一层的数据，嵌套层会指向原来的内存地址！
import copy # 导入copy模块
li=[1,2,3,[4,5,6]]
li2=copy.copy(li)
print(li)   # [1, 2, 3, [4, 5, 6]]
print(li2)  # [1, 2, 3, [4, 5, 6]]
print("li内存地址：",id(li))
print("li2内存地址：",id(li2))
# 发现内存地址不同！！！
li.append(8)
print(li)   # [1, 2, 3, [4, 5, 6], 8]
print(li2)  # [1, 2, 3, [4, 5, 6]]
# 此时一个值改变不会共享到另一个
#----------------------------------------------------------------------------------------
# 往嵌套列表里添加元素↓
li[3].append(7)
print(li)   # [1, 2, 3, [4, 5, 6, 7], 8]
print(li2)  # [1, 2, 3, [4, 5, 6, 7]]
# 发现两个列表中的嵌套列表都添加了7这个元素！！
# 这是因为两个列表中的嵌套列表的内存地址是一样的！↓
print("li[3]内存地址：",id(li[3]))
print("li2[3]内存地址：",id(li2[3]))
# 内存地址相同！！
# 外层的内存地址不同，但是内层的内存地址相同！！

# 优点：拷贝速度快，占用空间小，效率高

'''



# 深拷贝（数据完全不共享）
'''
# 外层对象和内部元素都拷贝了一遍
import copy #导入copy模块
li=[1,2,3,[4,5,6],7]
li2=copy.deepcopy(li)
print(li)   # [1, 2, 3, [4, 5, 6], 7]
print(li2)  # [1, 2, 3, [4, 5, 6], 7]
print(id(li))
print(id(li2))
# 内存地址不同！！
li.append(9)
print(li)   # [1, 2, 3, [4, 5, 6], 7, 9]
print(li2)  # [1, 2, 3, [4, 5, 6], 7]
# 外层数据不共享！
li[3].append(8)
print(li)   # [1, 2, 3, [4, 5, 6, 8], 7, 9]
print(li2)  # [1, 2, 3, [4, 5, 6], 7]
# 内层数据也不共享！！
print(id(li[3]))
print(id(li2[3]))
# 内存地址不同！！！

# 深拷贝数据变化只影响自己本身，跟原来的对象没有了任何关系！
'''





# 可变对象（存储空间保存的数据允许被修改）（list,dict,set)
# 变量对应的值可以被修改，但是内存地址不会发生改变！
'''
li=[1,2,3,4]
print(id(li))
li.append(5)
print(id(li))
# 内存地址没有改变！！！

'''


# 不可变对象（存储空间保存的数据不允许被修改）（int,bool,float,complex,str,tuple)
# 变量对应的值不可以被修改，如果修改，就会生成一个新的值，从而分配新的内存空间！
# 相当于重新定义！重新开辟内存空间！
'''
s=10
print(id(s))
s=15
print(id(s))
'''
# 内存地址改变了！！！










# 【函数】
'''
结构：
def 函数名():
    函数体
'''
'''
调用函数：
 函数名()
'''
'''
def login():
    print("这是一个函数")
login()
'''
# 注意，调用前必须确定函数已经存在！




# 返回值
'''
def x_and_y(x,y):
    return x+y
print(x_and_y(1,2))  # 输出3！
# return 如果返回多个值，则会以元组的形式返回给调用者！
def hello():
    return "hello",112233
print(hello())  # ('hello', 112233)
'''

# 函数的参数
# 1.必备参数（位置参数）
# 含义：传递和定义参数的顺序及个数必须一致
# def func(a,b)
'''
def fun(num1,num2,num3):
    print(num1)
    print(num2)
    print(num3)
fun(1,2,3)
fun('bbbb','eeee','tttt')
# 写几个传几个，不可以多传或少传
'''
# 2.默认参数（缺省参数）
# 含义：为参数提供默认值，调用函数时可以不传该默认参数的值
# 设置默认值没有传值会根据默认值来执行代码，传了值根据传入的值来执行代码
# 格式： def func(a=12)
'''
def func(a=18):
    print(a)
func()  # 18
func(200)   # 200
'''

# 注意：所有的位置参数必须出现在默认参数前，包括函数定义和调用
# 例如：
'''
def func(a=8,b):
    print(a)
func()
func(200)

会报错！！！
正确写法：
def func(b,a=8):
    print(a)
    
'''
# 3.可变参数
# 含义：传入的值的数量可以改变，可以传入多个，也可以不传
# def func(*args)
'''
def func(*args):# 可以将args改为其他的变量名，但args更符合规范
    print(args)
func(1,2,3,4,5)     # (1, 2, 3, 4, 5)   以元组形式接收
'''

# 4.关键字参数
# 格式： def func(**kwargs)        以字典形式接收
'''
def fund(**kwargs):
    print(kwargs)
fund(name='haha',age='18')
# 作用：可以扩展函数的功能
'''



# 【函数嵌套】
# 1.嵌套调用：在一个函数里面调用另外一个函数
'''
def study():
    print("我在学习")
def course():
    study()
    print("学习python")
course()
'''

# 2.嵌套定义：在一个函数里面定义另外一个函数
'''
def study():    # 外函数
    print("我在学习")
    def course():   # 内函数
        print("python基础")
    course()    # 定义和调用是同级的！注意缩进！！！ 调用如果在定义里面，则永远调用不出来！
study()
'''
# 注意！ 不要在内层函数中调用外层函数，会陷入死循环，直到超过递归的最大深度！




# 【作用域】——变量生效的范围，分为全局变量和局部变量
# 1.全局变量：函数外部定义的变量，在整个文件中都是有效的！
# 2.局部变量：函数内部定义的变量，从定义位置开始到函数定义结束有效！

# 在函数内部修改全局变量的值：可以使用global关键字
# 格式：global 变量名
'''
a=100
def aa():
    print(a)
def bb():
    a=200
    print(a)
def cc():
    global a    # 声明全局变量
    a=300
aa()    # 100
bb()    # 200
cc()
aa()    # 300
bb()    # 200
'''

#  nonlocal关键字： 用来声明外层局部变量
# 只能在嵌套函数中使用，在外部函数先进行声明，内部函数进行nonlocal声明
'''
a=10    # 全局变量
def outer():    # 外函数
    a=5         # 局部变量
    def inner():# 内函数
        nonlocal a  # nonlocal 会对外层进行修改！
        a=20
        print("inner函数中a的值：",a)
    inner()
    print("outer函数中a的值：",a)
outer()
# inner函数中a的值： 20
# outer函数中a的值： 20
'''


# 【匿名函数】
# 语法：函数名=lambda 形参 : 返回值(表达式)
# 调用：结果=函数名(实参)
'''
add = lambda a,b : a+b # a,b就是匿名函数的形参，a+b就是返回值的表达式，lambda不需要写return,表达式本身就是返回值
print(add(1,2)) # 3

# lambda 的参数形式：
# 1.无参数：
funa = lambda : "bingbingbangbang"
print(funa())   # bingbingbangbang

# 2.必备参数：
func = lambda name : name
print(func("bingbing"))     # bingbing

# 3.默认参数：
fund =lambda name,age=18 : (name,age) # 返回值以元组形式！
print(fund('bb'))   # ('bb', 18)
# 默认参数必须写在非默认参数后面！

# 4.可变参数/关键字参数：
funn = lambda **kwargs : kwargs
print(funn(name='bbb',age=18))  # {'name': 'bbb', 'age': 18}
'''

# 【lambda】结合 if 判断
'''
# 三目运算
a=5
b=8
print('a小于b') if a<b else print('a大于b') # a小于b
# 结合lambda
comp = lambda a,b : "a比b小" if a<b else print('a大于b')
print(comp(5,7))    # a比b小
# 特点：lambda只能实现简单的逻辑，如果逻辑复杂且代码量较大，不建议使用lambda，降低代码的可读性
'''


# 【内置函数】
# 查看所有的内置函数
import builtins
print(dir(builtins))
# 大写字母开头的一般是内置常量名，小写字母开头一般是内置函数名



# 【拆包】