Day 02 ：数据类型详解

1. 数字类型：int

数字主要是用于计算、运算。

1.1 bit_length()将十进制转化为二进制站的位数

'''
二进制             十进制
0000 0001            1
0000 0010            2
0000 0011            3
0000 0100            4
'''
x = 1
print(x.bit_length())
y = 10
print(y.bit_length())
z = 100
print(z.bit_length())

1.2 数字与字符串转化： int ---> str : str(int) str ---> int : int(str) str必须全部是数字组成

int ---> str : str(int)
str ---> int : int(str) str必须全部是数字组成
count = 1
print(str(count))
letter = '18'
print(int(letter))

2. 布尔值： bool

布尔值就两种：True，False。就是反应条件的正确与否。

2.1 布尔型与数字、字符串转化：

int ---> bool：        0 ---> False     非0 ---> True
bool---> int ：        int(True) ---> 1   int(False)---> 0
str ---> bool：        空字符串  ---> False  非空字符串---> True
print(int(True))    # >>> 1
print(int(False))   # >>> 0
print(bool(18))     # >>> True
print(bool(0))      # >>> False
print(bool('a'))    # >>> True
print(bool(''))     # >>> False

3. 字符串：str 可迭代，不可变的

3.1 字符串的拼接

字符串拼接：字符串只能进行"相加"和"相乘"运算。

x = 'Hello'
y = 'World '
z = '！'
print(x+y+z)    # HelloWorld！
x = 'Hello '
print(x*10)    # HelloHelloHelloHelloHelloHelloHelloHelloHelloHello

3.2 字符串的索引

索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。

l = 'Hello World！'
l1 = l[0]
l2 = l[-1]
l3 = l[-2]
print(l1)    # H
print(l2)    # ！
print(l3)    # d

3.3 字符串的切片

切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾首不顾尾）。

l[起始索引:结束索引+1:步长]

l = 'Hello World！'
l1 = l[0:5]     # 第1个字符到第4个字符
l2 = l[:5]      # 第1个字符到第4个字符，0可以省略
l3 = l[0:]      # 第1个字符到最后一个字符，结尾可以省略
l4 = l[:]       # 第一个字符到最后一个字符，开头和结尾都可以省略
l5 = l[0:-1]    # 第一个字符到最后1个字符，不顾尾
l6 = l[0:7:2]   # 第1个字符到第6个字符，步长为2
l7 = l[7:0:-2]  # 反向取字符串，加反向步长
print(l1)       # Hello
print(l2)       # Hello
print(l3)       # Hello World！
print(l4)       # Hello World！
print(l5)       # Hello World
print(l6)       # HloW
print(l7)       # o le

3.4 字符串的常用方法

3.4.1 upper() 字母全部大写 lower() 字母全部小写

l = 'Hello World！'
print(l.upper())    # HELLO WORLD！
print(l.lower())    # hello world！

#例：验证码不区分大小写
code = 'aBcD'.upper()
your_code = input('请输入验证码：').upper()
if your_code == code:
    print('验证成功')

3.4.2 strartswith() 判断以什么为开头 endswith() 判断以什么为结尾　

l = 'Hello World！'
print(l.startswith('h'))          # False
print(l.endswith('！'))           # True
print(l.startswith('l',2,5))      # True 
print(l.endswith('World！'))      # True

3.4.3 strip() 去除首尾的空格，制表符\t，换行符\n。不仅仅是去除空格，去除的元素可自定制。

l = ' Hello World！'
l1 = '\tHello World！\n'
l2 = '**Hello World！**'
l3 = 'niuHello World！uin'
print(l.strip())        # Hello World！
print(l1.strip())       # Hello World！
print(l2.strip('*'))    # Hello World！
print(l2.lstrip('*'))   # Hello World！**
print(l2.rstrip('*'))   # **Hello World！
print(l3.strip('inu'))  # Hello World！      # 迭代无序的去除首尾的‘i’‘n’‘u’

注：input都加strip
# 例：登录输入用户名密码清空收尾空格
name = input('请输入姓名：').strip()
pwd = input('请输入密码：').strip()
if name == 'niu' and pwd == '123':
    print('登录成功')
print(name)
print(pwd)

3.4.4 replace() 把字符串的旧字符串替换成新的字符串，如果指定第三个参数max，则替换不超过max次。

语法：str.replace(old,new,[max])

l = 'HellO WOrld！'
print(l.replace('O','o'))        # 默认全部替换
print(l.replace('O','o',1))      # 替换1次，只能从前往后替换，指定替换次数，不能指定替换

3.45 split() 字符串转化列表切分

以什么分割，最终形成一个列表此列表不含有这个分割的元素。

l = 'Hello World！'
print(l.split())            # ['Hello','World！']    # 默认以空格分隔
print(l.split('o'))         # ['Hell','W','rld！']   # 默认全部分割
print(l.split('o',1))       # ['Hell','World！']     # 分割1次，第1

3.4.6 join()将列表转化字符串切分

l = 'Hello World！'
l1 = ''.join(l)
print(l1,type(l1))    # Hello World！ <class 'str'>
l2 = '+'.join(l)    
print(l2,type(l2))    # H+e+l+l+o+ +W+o+r+l+d+！ <class 'str'>

s = ['Hello','World','！']
s1 = ''.join(s)
print(s1,type(s1))    # HelloWorld！ <class 'str'>
s2 = '+'.join(s)
print(s2,type(s))    Hello+World+！ <class 'str'>

3.4.7 find() 通过元素找索引找不到返回-1 index() 通过元素找索引找不到元素会报错

l = 'Hello World!'
l1 = l.find('llo',2,6)
l2 = l.find('ii')
print(l1,type(l1))         # 2 <class 'int'>    返回的找到的元素的索引
print(l2)        # -1    找不到返回-1

l3 = l.index('llo',2,6)
l4 = l.index('ii')      # substring not found    找不到报错
print(l3)               # 2    返回的找到的元素的索引
# print(l4)             # substring not found    找不到报错

3.4.8 center() 内容居中，总长度自己设定，默认填充为None

l = 'Hello World！'
l1 = l.center(30,)
l2 = l.center(30,'*')
print(l1)       #          Hello World！
print(l2)       # *********Hello World！*********

3.4.9 capitalize 首字母大写其余字母小写

l = 'hello World!'
print(l.capitalize())    # Hello world!

3.4.10 swapcase() 大小写翻转

l = 'Hello World！'
print(l.swapcase())    # hELLO wORLD！

3.4.11 title()非字母隔开的每个单词的首字母大写

l = 'helloworld！2hellochina！*hellobeijing！、hello沙河hello！'
print(l.title())     #Hello World！ Hello China！ Hello Beijing！Hello 沙河

3.4.12 format() 格式化输出三种方法

# 第一种：直接输入
l = '我叫{},今年{}岁，爱好{}'
print(l.format('niu','18','吃'))

# 第二种：通过索引赋值
l1 = '我叫{0}，今年{1}，爱好{2}，希望永远{1}岁！'
print(l1.format('niu',18,'吃'))

# 第三种：通过键赋值
l2 = '我叫{name}，今年{age}，爱好{hobby}，希望永远{age}岁！'
print(l2.format(name='niu',age=18,hobby='吃'))

3.4.13 is系列

l = 'niu123'
print(l.isdigit())      # False     # 字符串由数字组成
print(l.isalnum())      # True      # 字符串由字母或数字组成
print(l.isalpha())      # False     # 字符串由字母组成

3.4.14 len() 返回对象的长度或项目个数； count() 数字字符串的元素出现的个数

l = 'Hello World！ Hello China！ Hello Beijing！'
print(len(l))               # 40
print(l.count('H'))         # 3
print(l.count('H',0,20))    # 2        # 可切片

4. 列表：list

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

定义：[]内可以有多个任意类型的值，逗号分隔

4.1 列表的增

append()   追加
l1 = ['hello',123,[11,22,'ABC']]
l1.append(0)                # #增加到最后
l1.append('abc')            # #增加到最后
l1.append(['add',123])      # #增加到最后
print(l1)                   # ['hello', 123, [11, 22, 'ABC'], 0, 'abc', ['add', 123]]

insert() 按照索引插入
l = ['Hello','World','！',123,[11,22,33]]
l.insert(0,'niu')       # 按照索引去增加
print(l)                # ['niu', 'Hello', 'World', '！', 123, [11, 22, 33]]

extend() 迭代的加
l2 = [1,['aa',2],'abc']
l2.extend('0')
l2.extend(['abc',0])
l3 = ['123',0]
l2.extend(l3)            # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
l2.extend('xxx')        # 迭代的增
print(l2)               # [1, ['aa', 2], 'abc', '0', 'abc', 0, '123', 0, 'x', 'x', 'x']

4.2 列表的删

pop() 按照索引删除，返回被删除的值，增删改查中唯一一个有返回值的
l = [1,2,'a,b',['ab',0]]
print(l.pop(3))         # ['ab', 0]

remove() 按照元素去删除
l = [1,2,'a,b',['ab',0]]
l.remove('a,b')         # 删除 字符串元素
l.remove(['ab',0])      # 删除 列表元素
print(l)                # [1, 2]

cleat()  清空列表
l = [1,2,'a,b',['ab',0]]
l.clear()
print(l)            # []

del() # 按照索引、按照切片删除，也可删除列表没有返回值
del() 按索引删除
l = [1,2,'a,b',['ab',0]]
del l[0]        # 按照索引去删除，没有返回值
print(l)        # [2, 'a,b', ['ab', 0]]

del() 按切片删除
l = [1,2,'a,b',['ab',0]]
del l[2:4]      # 按着切片删除，没有返回值
print(l)        # [1,2]

del() 删除列表
l = [1,2,'a,b',['ab',0]]
del l           # 删除列表
print(l)        #  name 'l' is not defined

4.3 列表的改

按照索引改
l = ['hello','world','！']
l[0] = ('Hello')
print(l)        # ['Hello', 'world', '！']
l[2] = 'Hello World！'
print(l)        # ['Hello', 'world', 'Hello World！']

按照切片去改
l = ['Hello','World','！']
l[:2] = 'abc'
print(l)        # ['a', 'b', 'c', '！']
l[:2] = ['Hello World！',11]
print(l)        # ['Hello World！', 11, 'c', '！']
切片加步长去改，加步长 必须一一对应
l = ['H','e','l','l','o',' ','W','o','r','l','d','！']
l[:10:2] = ['bacde',1,2,3,4]        #加步长 必须一一对应
print(l)

4.4 列表的查

# 按照索引去查
l = ['Hello World！',5566,['abc',12]]
print(l[1]) # 5566
print(l[-1]) # ['abc', 12]
 
# 按照切片查询
l = ['Hello World！',5566,['abc',12]]
print(l[:1]) # ['Hello World！'] # 切片
print(l[:3:2]) # ['Hello World！', ['abc', 12]] # 切片加步长
 
# for 循环遍历
l = ['Hello World！',5566,['abc',12]]
for item in l:
print(item)

4.5 其他方法

# len() 长度
l = ['a','b','c','d','e','a']
print(len(l))
 
# count() 某个元素出现的次数
print(l.count('a'))
 
# sort() 正序排序(从大到小)
l.sort()
print(l)
 
reverse()倒叙排序
l.sort(reverse=True) # 倒叙排序（从小到大）
print(l)
 
# reverse() 翻转
l.reverse()
print(l)

4.6 列表的嵌套

l1 = [1, 2, 'abc', ['qUIt ','niu', 99], 6]
# 1,将abc该成Abc
l1[2] = l1[2].capitalize()
print(l1)
#2，将'qUIt变成全部大写。
l1[3][0] = l1[3][0].upper()
print(l1)
# 3，99让其通过数字加1的方式变成 '100'.
l1[-2][-1] = str(l1[-2][-1] + 1)
print(l1)
# 4，99让其通过字符串相加方式变成'100'
l1[-2][-1] = str(l1[-2][-1] )+ '9'
print(l1)

5. 元组：tuple

python的元组与列表类型，不同之处在于元组的元素不能修改（增删改）。

元组使用小括号()，列表使用方括号[]。只读列表，

元组创建很简单，只需要在括号里添加元素，并使用逗号隔开即可。

tu = (1,2,3,'abc',[5566],0)

5.1 元组的查

5.1.1 通过索引去查

print(tu[-2])

5.1.2 通过切片去查

print(tu[3:4]) # 切片
print(tu[:4:2]) # 切片加步长

5.1.3 循环查询

for i in tu:
print(i)
index() 通过元素找索引 count() 元素出现的个数 len() 元素的个数
print(tu.index(2)) # 1
print(tu.count('abc')) # 1
print(tu.count('a')) # 0
print(len(tu)) # 6
元素里的元素可以修改
tu[-2].append(7788)
print(tu) # (1, 2, 3, 'abc', [5566, 7788], 0)

5.2 range 自定义范围

print(range(100))
# 打印 0-99
for i in range(100):
print(i)
# 打印 0-100
for i in range(1,101):
print(i)
加步长 打印1-100的偶数
for i in range(2,101,2):
print(i)
倒着取值，打印100-0
for i in range(100,0,-1):
print(i)

6. 字典：dic

字典的key是唯一的。key必须是不可变的数据类型，value是任意数据类型。

数据类型分类：

不可变数据类型（可哈希）：str，bool,tuple,int。

可变数据类型（不可哈希）：dict，list，set。

容器类数据类型：list，tuple，dict，set。

字典：存储数据多，关系型数据，查询速度快(二分查找)

二分查找：也称折半查找（Binary Search），它是一种高效率的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中的元素按关键字有序排列。

备注：python3.5以前 (包含3.5)，字典无序

python3.6以后 (包含3.6)，进行了优化，不清楚到底是有序还是无序

6.1 字典的增

dic = {
'name':'niu' ,
'age':18,
'job':'test'
}

6.1.1 输入键增加

dic['hobby'] = '吃' # 无则增加
print(dic)
dic['name'] = 'zs' # 有则修改
print(dic)

6.1.2 setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则不会更改或者覆盖。

dic.setdefault('name','ls')
print(dic) # {'name': 'niu', 'age': 18, 'job': 'test'}
dic.setdefault('sex')
print(dic) # {'name': 'niu', 'age': 18, 'job': 'test', 'sex': None}
dic.setdefault('sex','male')
print(dic) # {'name': 'niu', 'age': 18, 'job': 'test', 'sex': None}
dic.setdefault('high',178)
print(dic) # {'name': 'niu', 'age': 18, 'job': 'test', 'sex': None, 'high': 178}

6.2 字典的删

dic = {
'name':'niu' ,
'age':18,
'job':'test'
}

6.2.1 pop() 通过键删除

print(dic.pop('name')) # niu # 返回值
print(dic.pop('name',None)) # niu

6.2.2 popitem() 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回，在python3.6以后，默认删除最后一个键值对

print(dic.popitem()) # 删除最后一个

6.2.3 clear() 清空字典

dic.clear()
print(dic) # {}

6.2.4 del() 删除字典，也可按键删除

del dic # 删除字典 内存级别删除
print(dic) # name 'dic' is not defined 报错，因为在内存级别已经删除
按键删除
del dic['name']
print(dic)

6.3 字典的改

dic = {
'name':'niu' ,
'age':18,
'job':'test'
}

6.3.1 通过键修改

dic['name'] = 'zs' # 无责增加，有责修改。
print(dic) # 将dic里面的键值对覆盖并更新到dic2中，dic不变 。

6.3.2 update() 覆盖并更新

dic = {'name':'niu' , 'age':18,'job':'test'}
dic1 = {'name':'zs','sex':'male','hobby':'吃'}
dic1.update(dic) # 将dic里面的键值对覆盖并更新到dic1中，dic不变 。
print(dic)
print(dic1)

6.4 字典的查

dic = {'name':'niu' ,'age':18,'job':'test'}

6.4.1 通过键去查，查不到键会报错

print(dic['name']) # niu
print(dic['name1']) # niu 查不到键会报错

6.4.2 get() 查不到不会报错，返回None

print(dic.get('name')) # niu
print(dic.get('name1')) # None
print(dic.get('name1','没有此键')) # 没有此键

6.4.3 键keys() 值values() 键值对items()

# 类似于列表的一个容器，没有索引
dic = { 'name':'niu' ,'age':18,'job':'test'}
print(dic.keys()) # dict_keys(['name', 'age', 'job'])
print(list(dic.keys())) # ['name', 'age', 'job']
print(dic.values()) # dict_values(['niu', 18, 'test'])
print(list(dic.values())) # ['niu', 18, 'test']
print(dic.items()) # dict_items([('name', 'niu'), ('age', 18), ('job', 'test')])
print(list(dic.items())) # [('name', 'niu'), ('age', 18), ('job', 'test')]

6.4.4 for循环取值

dic = { 'name':'niu' ,'age':18,'job':'test'}
for k in dic.keys():
print(k) # name age job
for v in dic.values():
print(v) # niu 18 test
for i in dic.items():
print(i) # ('name', 'niu') ('age', 18) ('job', 'test')
for k,v in dic.items():
print(k,v) # name niu # age 18 # job test

6.4.5 分别赋值

a,b = 1,3
print(a,b) # 1 3
a,b = [11,22]
print(a,b) # 11,22
a,b = b,a
print(a,b) # 3,1
a, b, c, d = ['niu', 'zs', 'li', 'ww']
print(a, b, c, d) # niu zs li ww

6.4.6 公共方法 len()

dic = { 'name':'niu' ,'age':18,'job':'test'}
print(len(dic)) # 3

6.4.7 fromkeys() 创建字典一种，以fromkeys()创建的键值对，如果值是列表的话，多个共用的都是一个列表

dic = dict.fromkeys('abc','666')
print(dic) # {'a': '666', 'b': '666', 'c': '666'}
dic1 = dic.fromkeys(['a','b','c'],'666')
print(dic1) # {'a': '666', 'b': '666', 'c': '666'}
dic2 = dic.fromkeys('abc',[])
dic2['a'].append('666')
print(dic2) # {'a': ['666'], 'b': ['666'], 'c': ['666']}

6.5 字典的嵌套

dic = {'name_list':['zs','ls'],
'l':{
'name':'ww',
'high':178,
}
}
#['zs','ls'] 追加一个元素'niu'，
dic['name_list'].append('niu')
print(dic)
# {'name':'ww','high':178,}增加一个键值对'sex': man，
dic['l']['sex'] = 'man'
print(dic)

7. 集合

集合：无序不重复的数据类型。它里面的元素必须是可哈希的，但是集合本身是不可哈希的。

　　集合是无序的，没有索引，不能改，只能‘增删查’

1、关系测试，交集，并集，子集，差集

2、去重（列表的去重）

set1={1,'alex',False,(1,2,3)}
l1=[1,1,2,2,3,3,4,5,6,6]
l2=(list(set(l1)))
print(l2)#>>>[1, 2, 3, 4, 5, 6]

7.1 增删查

# 集合的增  无序
set1={'Lily','Lucy'}
set1.add('Lucas')
print(set1) 　　# {'Lucas','Lily','Lucy'}
# 迭代着增加update()
set1={'Lily','Lucy'}
set1.update('Lucas')
print(set1)　　# {'a','Lily','u','c','L','s','Lucy'}
# 集合的删
# remove()按照元素删除
set1={'Lily','Lucy'}
set1.remove('Lucy')
print(set1)#>>>{'Lily'}
# pop()随机删除一个元素
set1={'Lily','Lucy'}
set1.pop()
print(set1)#>>>{'Lucy'}
# clear()清空集合
set1={'Lily','Lucy'}
set1.clear()
print(set1)#>>>set()
# del()内存级别删除集合
set1={'Lily','Lucy'}24delset125print(set1)#报错
# 集合的查
# for循环
for i in set1:
　　print(i)

7.2 集合其他操作

7.21 交集

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1 & set2 )#>>>{4, 5}
print(set1.intersection(set2))#>>>{4, 5}

7.22 并集

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1 | set2)#>>>{1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2))#>>>{1, 2, 3, 4, 5, 6, 7, 8}

7.23 差集

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1 - set2)#>>>{1, 2, 3}
print(set1.difference(set2))#>>>{1, 2, 3}

7.24 反交集

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1 ^ set2 )#>>>{1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))#>>>{1, 2, 3, 6, 7, 8}

7.25 子集

set1={1,2,3}
set2={1,2,3,4,5,6}
print(set1 < set2)#>>>True
print(set1.issubset(set2))#>>>True

7.26 超集

set1={1,2,3}
set2={1,2,3,4,5,6}
print(set2 > set1)#>>>True
print(set2.(set1))#>>>True

7.27 frozenset不可变集合，让集合变成不可变类型

s=frozenset('abc')
s1=frozenset({4,5,6,7,8})
print(s,type(s))#>>>frozenset({'c', 'b', 'a'}) <class 'frozenset'>
print(s1,type(s1))#>>>frozenset({4, 5, 6, 7, 8}) <class 'frozenset'>

8. 数据类型的补充

# 将索引为奇数对应的元素删除。
l = [11, 22, 33, 44, 55]
del l[1::2]
print(l)
 
# 在循环一个列表时，不要改变列表的大小，这样会影响结果。
# 从后往前删
l1 = [11, 22, 33, 44, 55]
for i in range(len(l1)-1,-1,-1):
if i % 2 == 1:
del l1[i]
print(l1)
 
# 在循环一个字典时，不要改变字典的大小，这样会影响结果。
dic={'k1':'v1','k2':'v2','k3':'v3','a1':'b1'}
l1 = []
for i in dic:
if 'k' in i:
l1.append(i)
for i in l1:
del dic[i]
print(dic)
#tu元组 如果元组里面只有一个元素并且没有逗号隔开，name他的数据类型与该元素一致
tu1=(1)
print(tu1,type(tu1))#>>>1 <class 'int'>
tu2=('Lucy')
print(tu2,type(tu2))#>>>Lucy <class 'str'>
tu3=(['alex',1,2])
print(tu3,type(tu3))#>>>['alex', 1, 2] <class 'list'>

9. 深浅Copy

9.1 先看赋值运算

l1 = [1,2,3,['barry','alex']]
l2 = l1

l1[0] = 111
print(l1)  # [111, 2, 3, ['barry', 'alex']]
print(l2)  # [111, 2, 3, ['barry', 'alex']]

l1[3][0] = 'wusir'
print(l1)  # [111, 2, 3, ['wusir', 'alex']]
print(l2)  # [111, 2, 3, ['wusir', 'alex']]

# 对于赋值运算来说，l1与l2指向的是同一个内存地址，所以他们是完全一样的。

9.2 浅拷贝copy

l1 = [1,2,3,['barry','alex']]

l2 = l1.copy()
print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2380296895816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2380296895048
l1[1] = 222
print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2593038941128
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2593038941896
 
l1[3][0] = 'wusir'
print(l1,id(l1[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016
print(l2,id(l2[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016

# 对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。

9.3 深拷贝deepcopy

import copy
l1 = [1,2,3,['barry','alex']]
l2 = copy.deepcopy(l1)

print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2915377167816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[1] = 222
print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2915377167816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[3][0] = 'wusir'
print(l1,id(l1[3]))  # [1, 222, 3, ['wusir', 'alex']] 2915377167240
print(l2,id(l2[3]))  # [1, 2, 3, ['barry', 'alex']] 2915377167304

posted @ 2018-05-17 16:56 牛小白阅读(340) 评论(0) 编辑收藏举报

刷新页面返回顶部

牛小白

Day 02 ：数据类型详解

1. 数字类型 ：int

1.1 bit_length()将十进制转化为二进制站的位数

1.2 数字与字符串转化： int ---> str : str(int) str ---> int : int(str) str必须全部是数字组成

2. 布尔值 ： bool

2.1 布尔型与数字、字符串转化：

3. 字符串：str 可迭代，不可变的

3.1 字符串的拼接

3.2 字符串的索引

3.3 字符串的切片

3.4 字符串的常用方法

3.4.1 upper() 字母全部大写 lower() 字母全部小写

3.4.2 strartswith() 判断以什么为开头 endswith() 判断以什么为结尾

3.4.3 strip() 去除首尾的空格，制表符\t，换行符\n。不仅仅是去除空格，去除的元素可自定制。

3.4.4 replace() 把字符串的旧字符串替换成新的字符串，如果指定第三个参数max，则替换不超过max次。

3.45 split() 字符串 转化 列表 切分

3.4.6 join()将列表 转化 字符串 切分

3.4.7 find() 通过元素找索引 找不到返回-1 index() 通过元素找索引 找不到元素会报错

3.4.8 center() 内容居中，总长度自己设定，默认填充为None

3.4.9 capitalize 首字母大写其余字母小写

3.4.10 swapcase() 大小写翻转

3.4.11 title()非字母隔开的每个单词的首字母大写

3.4.12 format() 格式化输出 三种方法

3.4.13 is系列

3.4.14 len() 返回对象的长度或项目个数； count() 数字字符串的元素出现的个数

4. 列表：list

4.1 列表的增

4.2 列表的删

4.3 列表的改

4.4 列表的查

4.5 其他方法

4.6 列表的嵌套

5. 元组：tuple

5.1 元组的查

5.1.1 通过索引去查

5.1.2 通过切片去查

5.1.3 循环查询

5.2 range 自定义范围

6. 字典：dic

6.1 字典的增

6.1.1 输入键增加

6.1.2 setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则不会更改或者覆盖。

6.2 字典的删

6.2.1 pop() 通过键删除

6.2.2 popitem() 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回，在python3.6以后，默认删除最后一个键值对

6.2.3 clear() 清空字典

6.2.4 del() 删除字典，也可按键删除

6.3 字典的改

6.3.1 通过键修改

6.3.2 update() 覆盖并更新

6.4 字典的查

6.4.1 通过键去查，查不到键会报错

6.4.2 get() 查不到不会报错，返回None

6.4.3 键keys() 值values() 键值对items()

6.4.4 for循环取值

6.4.5 分别赋值

6.4.6 公共方法 len()

6.4.7 fromkeys() 创建字典一种，以fromkeys()创建的键值对，如果值是列表的话，多个共用的都是一个列表

6.5 字典的嵌套

7. 集合

7.1 增删查

7.2 集合其他操作

7.21 交集

7.22 并集

7.23 差集

7.24 反交集

7.25 子集

7.26 超集

7.27 frozenset不可变集合，让集合变成不可变类型

8. 数据类型的补充

9. 深浅Copy

9.1 先看赋值运算

9.2 浅拷贝copy

9.3 深拷贝deepcopy

公告

1. 数字类型：int

2. 布尔值： bool

3.4.2 strartswith() 判断以什么为开头 endswith() 判断以什么为结尾　

3.45 split() 字符串转化列表切分

3.4.6 join()将列表转化字符串切分

3.4.7 find() 通过元素找索引找不到返回-1 index() 通过元素找索引找不到元素会报错

3.4.12 format() 格式化输出三种方法