python如何开发全栈_python 全栈开发笔记 1

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

#自己姓名的进制表示

name=input('请输入你的名字:')for i inname:print(i) #python 3 中是按字符进行循环的

bytes_name=bytes(name,encoding='utf-8')'''将名字的每个字符转化成字节类型

但需要指定编码类型，因为不同的编码类型 ,一个字符对应的字节数也不相同

UTF-8 编码 ，一个汉字，3个字节，GBK 一个汉字，2个字节'''

print(bytes_name) #打印出名字的字节表示，默认是16进制的编码

for i inbytes_name:print(i)#用for循环来遍历 bytes_name 默认打印出来是以 10进制显示出来的

for i inbytes_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=2name='alex' if x == 1 else 'elex' #如果x=1则输出 alex 否则输出 elex

print(name) #输出elex

深浅拷贝

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

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

#对于字符串和数字拷贝、赋值等

importcopy

n1='123asd' #对于字符串或者数字，不管深拷贝还是浅拷贝，它们的最后输出的id都是一样的#python内部的优化机制

n2=copy.deepcopy(n1) #深拷贝

n3=copy.copy(n2)#浅拷贝

print(id(n1))print(id(n2))print(id(n3))#对于字典、列表、等

importcopy

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'])) #输出的地址一样，说明内部的地址并没有变

#深拷贝

importcopy

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},]

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

importcopy

comment_list=[]

comment_dict={}for i in range(10):

comment_dict['num'] =i

comment_list.append(comment_dict.copy()) #浅拷贝只拷贝第一层，所以只有第一层内存地址会变print(comment_list)