一、运算符
in
“hello” in “asdfashellosdfadfadfa”
"li" in ['li','ok']
二、基本数据类型
int
a、创建方式
n1 = 123 #根据int类,创建了一个对象
n2 = int123 #根据int类,创建了一个对象
特有的功能在:
int类
功能1
功能1
功能1
...
__init__ 初始化
b、int内部优化
n1 = 123
n2 = n1
n1 = 123
n2 = 123
=====两份内存=====
-5~257 这个可以通过修改源码改变,由c语言演变过来的,查源码
n1 = 123
n2 = 123
n1 = 123
n2 = 123
==》对象的内存地址=id(对象或对象的变量名)这样可以查看内存地址
c、长度限制
用int,超出了范围(根据计算机的不同定义的)
32位的操作系统 -2**31 ~ 2**31-1
64位的操作系统 -2**63 ~ 2**63-1
long
bytes:可以将字符转换成字节
str
a、创建方式
s1 = "zq"
s1 = str("zq")
b、特有的功能
#两端去除空格
#s1.strip()
#以...开头
#s1.startwith()
#找子序列
#s1.find()
#将字符串中的某子序列替换成指定的值
#s1.replace()
#变大写
#s1.upper()
#是...吗?
#s1.isalpha()
c、公共功能
索引:只能取一个元素
切片:取多个元素
len:
for:
编码、for:
name = "李露"
for i in name:
print (i)
bytes_list = bytes(i, encoding='utf-8')
print(bytes_list)
for b in bytes_list:
#字节默认16进制
#输出每一个字节默认16进制
print(b,bin(b))
1、 3.6版本中for循环时候,循环的每一个元素是“字符”
2、 字符=》 字节
bytes_list = bytes(“字符串”,encoding=‘utf-8’)
#utf-8 -》 3字节
#gbk -》 2字节
print(bytes_list)#默认每一个字节都是16进制
for b in bytes_list :
print(b) #默认每一个字节都是10进制
3、 10进制的数字 ==》 2进制
len
id
bin(10进制的数字)
d、 bytes和str的转换
a = "张强"
#将字符串转换成字节
b1 = bytes(a, encoding='utf-8')
print(b1)
b2 = bytes(a,encoding='gbk')
print(b2)
#将字节转换成字符串
print(str(b1,encoding='utf-8'))
print(str(b2,encoding='gbk'))
#########
x = str()
#创建字符串
#转换成字符串
o = bytes()
#创建字节
#转换成字节,字符串,要编程什么编码类型的字节
str()
str类__init__
list
a、创建和转换
1、创建
可变的元素的“集合”,列表
li = [11,22,33,44]
li = list()
------------
str -> 创建字符串,或者将其他的转换成字符串
list -> 创建列表,将其他元素转换成列表
li = ([11,22,33,44])
2、转换
#iterable可迭代的: for可以循环的
a1 = "张强"
#for,字符 ==> iterable
li = list(a1) #for循环,将循环的每一个元素,当做列表的元素
print(li)
#########字典#######
dic = {"k1":"zq","k2":"sdfsdf"}#注意是大括号
l3 = list(dic)
print(l3)
l4 = list(dic.values())
print(l4)
l5 = list(dic.items())
print(l5)
#字符串,元组,字典 =》 列表
b、 列表特有功能
li = [11,22,3]
#追加
# li.append()
#清楚
#li.clear()
#扩展自己,用另外一个可迭代的对象扩充到自己
#str字符串,列表list,字典dic,元组tuple
# z = "张强"
# li.extend(z)
# print(li)
#翻转,自己内部元素翻转
#li.reverse()
#向指定位置插入指定元素
# li.insert(1,'x')
# print(li)
c、 公共功能
li = ["zq","fd","gg","rg"]
索引:只能取一个元素
切片:取多个元素
li = ["sdf","sdfe","hdf","sdgx"]
print(li[1])
print(li[1:3])
sdfe #索引
['sdfe', 'hdf'] #切片 本来是什么类型,切片取出来的就是什么类型
for
len
d、 多层嵌套
li = ['sdf','dff','we','gr']
li = ["zq",12,{"k1":"b1","b2":{"qq":(11,22,33),"ii":741}}]
li[2] --> {"k1":"b1","b2":{"qq":(11,22,33),"ii":741}}
li[2]['k2'] ==> {"qq":(11,22,33),"ii":741}
li[2]['k2']["qq"] --> {11,22,33}
元组tuple
a、创建和转换
t = (11,22,33)
t = tuple((11,22,33))
t = tuple{[]} #字符串、列表、字典
b、 特有的方法
count index
c、 嵌套(元素不可修改)
t = (11,22,33)
t = (11,22,["zq",{"zq1":"z1"}])
t[2] = ["zq",{"zq1":"z1"}]
t[2][1] = {"zq1":"z1"}
t[2][1]["zq1"]
e、 元组的特性,不可修改,谁不可修改---元组的元素不可修改,元素的元素可以修改
#给字典里面的元素添加新元素,两种方法
dic = {"zq1":"zz"}
# dic.update({"zq2":15}) #新添加的元素注意加大括号
# print(dic)
dic["zq2"] = 15
print(dic)
# t = (11,22,33)
t = (11,22,["zq",{"zq1":"z1"}])
# print(t[2])
# print(t[2][1])
# print(t[2][1]["zq1"])
# print(t)
# t[2].append("zz")
# print(t)
t = (11,22,["zq",{"zq1":"z1"}])
t[2][1]["zq2"]=15
print(t)
t[2][1].update({"zq3":15})
print(t)
#什么时候是自身的变化什么时候产生新的
#一般对于字符串的操作
一般字符串,执行一个功能,生成一个新内容,原来内容不变
list、tuple、dic,执行一个功能,自身进行变化
字典:
1.创建
a = {"z1":8}
a = dict()
li = [11,22,33]
# new_dict = dict(li) #这是不可以的
# new_dict = dict(enumerate(li,10))
new_dict = dict(enumerate(li,1))
print(new_dict)
#想要把列表转换过来,只能用enumerate
2.字典的内部功能
dic = {"k1":123,"k2":456,"k3":566}
#方法,无@staticmothod,对象.方法
# dic.get()
#k1,k2,默认值123
#方法,有@staticmothod,类.方法
# n = dic.fromkeys(['k1','k2','k3'],"123")
#fromkeys 的功能就是寻找到字典里面存在的key值,重新给其重新赋值
# n = dict.fromkeys(['k1','k2','k3'],"123")
# print(n)
n = dict.fromkeys(['k1','k2','k3'],[])
print(n)
n['k1'].append('x')
print(n)
in
“hello” in “asdfashellosdfadfadfa”
"li" in ['li','ok']
二、基本数据类型
int
a、创建方式
n1 = 123 #根据int类,创建了一个对象
n2 = int123 #根据int类,创建了一个对象
特有的功能在:
int类
功能1
功能1
功能1
...
__init__ 初始化
b、int内部优化
n1 = 123
n2 = n1
n1 = 123
n2 = 123
=====两份内存=====
-5~257 这个可以通过修改源码改变,由c语言演变过来的,查源码
n1 = 123
n2 = 123
n1 = 123
n2 = 123
==》对象的内存地址=id(对象或对象的变量名)这样可以查看内存地址
c、长度限制
用int,超出了范围(根据计算机的不同定义的)
32位的操作系统 -2**31 ~ 2**31-1
64位的操作系统 -2**63 ~ 2**63-1
long
bytes:可以将字符转换成字节
str
a、创建方式
s1 = "zq"
s1 = str("zq")
b、特有的功能
#两端去除空格
#s1.strip()
#以...开头
#s1.startwith()
#找子序列
#s1.find()
#将字符串中的某子序列替换成指定的值
#s1.replace()
#变大写
#s1.upper()
#是...吗?
#s1.isalpha()
c、公共功能
索引:只能取一个元素
切片:取多个元素
len:
for:
编码、for:
name = "李露"
for i in name:
print (i)
bytes_list = bytes(i, encoding='utf-8')
print(bytes_list)
for b in bytes_list:
#字节默认16进制
#输出每一个字节默认16进制
print(b,bin(b))
1、 3.6版本中for循环时候,循环的每一个元素是“字符”
2、 字符=》 字节
bytes_list = bytes(“字符串”,encoding=‘utf-8’)
#utf-8 -》 3字节
#gbk -》 2字节
print(bytes_list)#默认每一个字节都是16进制
for b in bytes_list :
print(b) #默认每一个字节都是10进制
3、 10进制的数字 ==》 2进制
len
id
bin(10进制的数字)
d、 bytes和str的转换
a = "张强"
#将字符串转换成字节
b1 = bytes(a, encoding='utf-8')
print(b1)
b2 = bytes(a,encoding='gbk')
print(b2)
#将字节转换成字符串
print(str(b1,encoding='utf-8'))
print(str(b2,encoding='gbk'))
#########
x = str()
#创建字符串
#转换成字符串
o = bytes()
#创建字节
#转换成字节,字符串,要编程什么编码类型的字节
str()
str类__init__
list
a、创建和转换
1、创建
可变的元素的“集合”,列表
li = [11,22,33,44]
li = list()
------------
str -> 创建字符串,或者将其他的转换成字符串
list -> 创建列表,将其他元素转换成列表
li = ([11,22,33,44])
2、转换
#iterable可迭代的: for可以循环的
a1 = "张强"
#for,字符 ==> iterable
li = list(a1) #for循环,将循环的每一个元素,当做列表的元素
print(li)
#########字典#######
dic = {"k1":"zq","k2":"sdfsdf"}#注意是大括号
l3 = list(dic)
print(l3)
l4 = list(dic.values())
print(l4)
l5 = list(dic.items())
print(l5)
#字符串,元组,字典 =》 列表
b、 列表特有功能
li = [11,22,3]
#追加
# li.append()
#清楚
#li.clear()
#扩展自己,用另外一个可迭代的对象扩充到自己
#str字符串,列表list,字典dic,元组tuple
# z = "张强"
# li.extend(z)
# print(li)
#翻转,自己内部元素翻转
#li.reverse()
#向指定位置插入指定元素
# li.insert(1,'x')
# print(li)
c、 公共功能
li = ["zq","fd","gg","rg"]
索引:只能取一个元素
切片:取多个元素
li = ["sdf","sdfe","hdf","sdgx"]
print(li[1])
print(li[1:3])
sdfe #索引
['sdfe', 'hdf'] #切片 本来是什么类型,切片取出来的就是什么类型
for
len
d、 多层嵌套
li = ['sdf','dff','we','gr']
li = ["zq",12,{"k1":"b1","b2":{"qq":(11,22,33),"ii":741}}]
li[2] --> {"k1":"b1","b2":{"qq":(11,22,33),"ii":741}}
li[2]['k2'] ==> {"qq":(11,22,33),"ii":741}
li[2]['k2']["qq"] --> {11,22,33}
元组tuple
a、创建和转换
t = (11,22,33)
t = tuple((11,22,33))
t = tuple{[]} #字符串、列表、字典
b、 特有的方法
count index
c、 嵌套(元素不可修改)
t = (11,22,33)
t = (11,22,["zq",{"zq1":"z1"}])
t[2] = ["zq",{"zq1":"z1"}]
t[2][1] = {"zq1":"z1"}
t[2][1]["zq1"]
e、 元组的特性,不可修改,谁不可修改---元组的元素不可修改,元素的元素可以修改
#给字典里面的元素添加新元素,两种方法
dic = {"zq1":"zz"}
# dic.update({"zq2":15}) #新添加的元素注意加大括号
# print(dic)
dic["zq2"] = 15
print(dic)
# t = (11,22,33)
t = (11,22,["zq",{"zq1":"z1"}])
# print(t[2])
# print(t[2][1])
# print(t[2][1]["zq1"])
# print(t)
# t[2].append("zz")
# print(t)
t = (11,22,["zq",{"zq1":"z1"}])
t[2][1]["zq2"]=15
print(t)
t[2][1].update({"zq3":15})
print(t)
#什么时候是自身的变化什么时候产生新的
#一般对于字符串的操作
一般字符串,执行一个功能,生成一个新内容,原来内容不变
list、tuple、dic,执行一个功能,自身进行变化
字典:
1.创建
a = {"z1":8}
a = dict()
li = [11,22,33]
# new_dict = dict(li) #这是不可以的
# new_dict = dict(enumerate(li,10))
new_dict = dict(enumerate(li,1))
print(new_dict)
#想要把列表转换过来,只能用enumerate
2.字典的内部功能
dic = {"k1":123,"k2":456,"k3":566}
#方法,无@staticmothod,对象.方法
# dic.get()
#k1,k2,默认值123
#方法,有@staticmothod,类.方法
# n = dic.fromkeys(['k1','k2','k3'],"123")
#fromkeys 的功能就是寻找到字典里面存在的key值,重新给其重新赋值
# n = dict.fromkeys(['k1','k2','k3'],"123")
# print(n)
n = dict.fromkeys(['k1','k2','k3'],[])
print(n)
n['k1'].append('x')
print(n)
来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/31453498/viewspace-2138503/,如需转载,请注明出处,否则将追究法律责任。
转载于:http://blog.itpub.net/31453498/viewspace-2138503/