python 全栈开发笔记 1

将自己的姓名用进制表示出来

#自己姓名的进制表示
name=input('请输入你的名字:')
for i in name:
    print(i) # python 3 中是按字符进行循环的
bytes_name=bytes(name,encoding='utf-8')
'''将名字的每个字符转化成字节类型
但需要指定编码类型，因为不同的编码类型 ,一个字符对应的字节数也不相同
UTF-8 编码  ，一个汉字，3个字节，GBK 一个汉字，2个字节'''
print(bytes_name)  #打印出名字的字节表示，默认是16进制的编码
for i in bytes_name:
    print(i)#用for循环来遍历 bytes_name  默认打印出来是以 10进制显示出来的
for i in bytes_name:
    print(bin(i))#  bin  接收一个十进制的数字 让它转化成2进制

bytes为字节类型   str 为字符串类型  一般只接受一个参数 str() ,但也可以传入两个参数  但为  str(bytes类型，bytes类型所对应的编码)

name ='小明'
#将字符串转化成字节
b1=bytes(name,encoding='utf-8')
print(b1)
b2=bytes(name,encoding='gbk')
print(b2)
#不同的编码类型转化成的字节也不相同

#将字节转化成字符串
name_str1=str(b1,encoding='utf-8') #编码类型必须和 所转化的字节类型相对应
print(name_str1)

name_str2=str(b2,encoding='gbk')
print(name_str2)

list 列表的创建和修改

元素的集合   str  -->创建字符串，或者将其他的转换成字符串    list->>创建列表，将其他的转换成列表

1.创建 li=[11,22,33,44]  li=list()   li= list([11,22,33,44])

2.转换  只要是可迭代的都能转换成 列表

#只要是可迭代的都能转化成列表
#将字符串转化成列表
s1='xiaoming'
s1_list=list(s1)
print(s1)
print(s1_list)

#将元组转化成列表
s2=('xiao','ming')
s2_list=list(s2)
print(s2)
print(s2_list)

#将字典转化成列表
dic={'k1':'xiao','k2':'ming'}
dic_list=list(dic)
print(dic_list)   #默认只转化字典的key，因为默认循环字典也只循环key

list.extend()用一个可迭代的对象，扩充到自己的内部 list.reverse() 自己内部元素反转   list.insert(1,'xx')  向指定位置插入元素

公共功能：索引，切片

元组的创建和转换

t=(11,22,33)  t=tuple((11,22,33))   t= tuple([ ])  #可迭代的   字符串  、列表 、  字典

特有的方法   count   index    嵌套（元素不可修改）  t=(11,22,['sdad',{'k1':'sda'}])

元组的元素不可被修改，但元组的元素的内部可以被修改

整理：

一般字符串，执行一个功能，生成一个新内容，原来内容不变,但列表了，字典了 都会直接发生变化

set

set 不允许重复的集合  ，但可以修改

创建:

s=set()   s={11,22,33,44}

转换：

s=set(‘可迭代的’)

s1=set([11,22,33,11])
print(s1)  #输出 {33，11，22}

功能 方法   增加 add  清除  clear   difference  比较两个集合的不同

# difference
se={11,22,33}
si={11,33,44,55,66}
print(se.difference(si))#输出se 中存在的 ，si 中不存在的  结果为{22}，但 se和si 不变

# difference_update
se={11,22,33}
si={11,33,44,55,66}
se.difference_update(si)#找出se 中存在的， si 中不存在的 并更新自己，输出se 为{22}

#discard  remove 移除某个元素
se={11,22,33}
se.discard(11)
se.remove(22)
se.discard(44)#不报错，不存在也不会报错
se.remove(44)# 报错，元素不存在

#  intersection(只取出交集不更新自己)  intersection_update (取交集并更新自己)
#  isdisjoint (判断是否有交集，有交集是False，无交集为 True)
#   se.symmetric_difference(si)   把它们所有不一样的一次性拿出来 ，对称交集
#   se.symmetric_difference_update(si)   把它们所有不一样的一次性拿出来 ，对称交集,并更新自己  se  改变
#  union()  取并集
#  update()  向集合 更新元素，一次可多个，可添加可迭代的对象  ，add 只能一次一个  

#  se.issuperset(si)   判断se 是不是 si 的 父序列
# se.issubset(si)      判断se 是不是si 的子序列
#   ret=se.pop()     移除最上面的元素 ，并可赋值给某个变量，而remove 和discard并不能赋值，只能移除

三目运算,三元运算

x=2
name ='alex' if x == 1 else 'elex' # 如果x=1则输出 alex  否则输出 elex
print(name) #输出elex
    

深浅拷贝

str 一次性创建，不能被修改，只要修改，再创建

# 列表 相当于   链表 相当于是动态创建的

# 对于字符串和数字拷贝、赋值等
import copy
n1 ='123asd' #对于字符串或者数字，不管深拷贝还是浅拷贝，它们的最后输出的id都是一样的
#python内部的优化机制
n2=copy.deepcopy(n1) #深拷贝
n3=copy.copy(n2)# 浅拷贝
print(id(n1))
print(id(n2))
print(id(n3))

#对于字典、列表、等
import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n2=copy.copy(n1)#浅拷贝
print(id(n1))
print(id(n2)) # 输出的地址并不相同，它们只拷贝了最外面的一层,里面的一层并没有拷贝
#还是指向原来的内存地址
print(id(n1['k1']))
print(id(n2['k1'])) #输出的地址一样，说明内部的地址并没有变

#深拷贝
import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n3=copy.deepcopy(n1) #  深拷贝，除了最后一层不拷贝，其余都拷贝
print(id(n1))
print(id(n3))
# k1 属于最后一层 ，不拷贝，输出地址一样
print(id(n1['k1']))
print(id(n3['k1']))
# k2  也属于最后一层 ，不拷贝，输出地址一样
print(id(n1['k2']))
print(id(n3['k2']))
# 输出的地址不一样说明第二层已经拷贝
print(id(n1['k3']))
print(id(n3['k3'])) 

在for循环中列表追加字典结果出现列表中的字典都一样

comment_list = []
comment_dict ={}
for i in range(10):
    comment_dict['num'] = i
    comment_list.append(comment_dict)

print(comment_list)

上面的输出结果都为 [{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},]

因为深浅拷贝的问题，正确的代码应该为：

import copy
comment_list = []
comment_dict ={}
for i in range(10):
    comment_dict['num'] = i
    comment_list.append(comment_dict.copy()) #浅拷贝只拷贝第一层，所以只有第一层内存地址会变

print(comment_list)