python_fullstack基础(三)-基本数据类型

python_fullstack基础(三)

1、int(数字类型)

1.1 介绍

表示数字0 - 9

1.2 常用方法

输出数字的位长：bit_length()

# 因为十进制数18的二进制为10010，即bin(18) = 10010，所以18的位长是5i = 18print(i.bit_length())>>>5

2、boolen(布尔类型)

2.1 介绍

布尔值只有True和False，同时True对应二进制中1，False对应二进制中0

# 其他数据类型与布尔类型的相互转换int ——> boolen    非0数值的布尔值：True    数字0的布尔值：Falsestr——> boolen    非空字符串的布尔值：True    空字符串的布尔值：Falseboolen——>int    True: 1    False: 0

3、string(字符串类型)

3.1 介绍

在单引号、双引号、三引号内，由一串字符组成的叫字符串

3.2 字符串的索引与切片

字符串索引

s = 'ABCDEFGHIJK'print(s[0])>>> 'A'print(s[2])>>> 'C'print(s[-1])>>>'K'print(s[-2])>>> 'J'

字符串切片：顾头不顾尾

s = 'ABCDEFGHIJK'print(s[0:4])>>>'ABCD'print(s[0:-1])>>>'ABCDEFGHIJ'print(s[:])>>>'ABCDEFGHIJK'print(s[0:])>>>'ABCDEFGHIJK'print(s[0:0])>>>s = 'ABCDEFGHIJK'  # s[首:尾:步长]print(s[0:5:2])>>>'ACE'print(s[4:0:-1])>>>'EDCB'print(s[3::-1])>>>'DCBA'print(s[3::-2])>>>'DB'print(s[-1::-1])>>>'KJIHGFEDCBA'print(s[::-1])>>>'KJIHGFEDCBA'

3.3 常用方法

s = 'PytHOn'# captalize,swapcase,titleprint(s.capitalize())>>>'Python'print(s.swapcase())>>>'pYThoN's1 = '-python*fullstack@s9'print(s1.title())>>>'-Python*Fullstack@S9'# upper、lowerprint(s.upper())>>>'PYTHON'print(s.lower())>>>'python'# center、expandtabsprint(s.center(20, '*'))>>>'*******PytHOn*******'# 在\t前面不全8或8的倍数个空格，如果有字符的话字符先顶头s2 = 'python\tfullstack'print(s2.expandtabs())>>>'python  fullstack'# 公共方法len()print(len(s))>>>6# startswith、endswithprint(s.startswith('Py'))>>>Trueprint(s.startswith('Py', 1, 4))>>>Falseprint(s.endswith('On'))>>>Trueprint(s.endswith('On'), 4)>>>True# find、indexprint(s.find('H'))>>>3print(s.index('H'))>>>3# strip rstrip lstrips3 = '  python 'print(s3.strip())>>>'python's4 = ' @python*@'print(s4.strip('*@'))>>>' @python'print(s.rstrip())>>>' @python'print(s.lstrip())>>>' @python*@'# counts5 = 'life is short we use python'print(s5.count('s'))>>>3s6 = 'lifeisshortweusepython'print(s6.split('s'))>>>['lifei','','hortweu','epython']# format 三种用法s7 = '大家好我叫{}，我今年{}，我喜欢{}，再说一遍我叫{}'print(s7.format('ELijah', 26, 'coding', 'Elijah'))>>>大家好我叫ELijah，我今年26，我喜欢coding，再说一遍我叫Elijahs8 = '大家好我叫{0}，我今年{1}，我喜欢{2}，再说一遍我叫{0}'print(s8.format('ELijah', 26, 'coding'))>>>大家好我叫ELijah，我今年26，我喜欢coding，再说一遍我叫Elijahs9 = '大家好我叫{name}，我今年{age}，我喜欢{hobby}，再说一遍我叫{name}'print(s9.format(hobby='coding', name='ELijah', age=26))>>>大家好我叫ELijah，我今年26，我喜欢coding，再说一遍我叫Elijah

4、list(列表类型)

4.1 介绍

列表是我们最以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作。

4.2 常用方法

# list列表常用方法# 增# 在列表末尾添加元素lst = ['C','Java','C++','Ruby','PHP']lst.append('Python')print(lst)>>> ['C','Java','C++','Ruby','PHP','Python']# 在指定索引前插入元素lst = ['C','Java','C++','Ruby','PHP']lst.insert(3,'Python')print(lst)>>> ['C','Java','C++','Python','Ruby','PHP']# 以迭代的方式在列表末尾添加元素lst = ['C','Java','C++','Ruby','PHP']lst.extend('Python')print(lst)>>> ['C','Java','C++','Python','Ruby','PHP','P','y','t','h','o','n']# 删 # 删除指定索引的元素，默认无索引则删除最后一个元素lst = ['C','Java','C++','Ruby','PHP']lst.pop(3)print(lst)>>> ['C','Java','C++','PHP']# pop()有返回值，返回删除掉的元素print(lst.pop(3))>>> 'Ruby'lst = ['C','Java','C++','Ruby','PHP']lst.pop()print(lst)>>> ['C','Java','C++','Ruby']# pop()有返回值，返回删除掉的元素print(lst.pop())>>> 'PHP'# 删除指定元素lst = ['C','Java','C++','Ruby','PHP']lst.remove('Ruby')print(lst)>>> ['C','Java','C++','PHP']# 清空列表所有元素lst = ['C','Java','C++','Ruby','PHP']lst.clear()print(lst)>>> []# 删除列表lst = ['C','Java','C++','Ruby','PHP']del lstprint(lst)>>> Traceback (most recent call last):      File "D:practice.py", line 5, in <module>        print(lst)    NameError: name 'lst' is not defined# 删除列表指定索引元素lst = ['C','Java','C++','Ruby','PHP']del lst[3:]print(lst)>>> ['C','Java','C++']# 改# 直接指定元素索引并赋予新值进行修改lst = ['C','Java','C++','Ruby','PHP']lst[3] = 'Python'print(lst)>>> ['C','Java','C++','Python','PHP']# 利用切片进行迭代修改lst = ['C','Java','C++','Ruby','PHP']lst[3:] = 'Python'print(lst)>>> ['C','Java','C++','P','y','t','h','o','n']# 查# 通过循环迭代查询列表中元素lst = ['C','Java','C++','Ruby','PHP']for i in lst:    print(i)# 切片查询列表中一部分元素lst = ['C','Java','C++','Ruby','PHP']print(lst[0:3])>>> ['C','Java','C++']#---------------------------------------# 列表排序# 正序排序lst = [4,3,2,5,7,8,9,1,6,0]lst.sort()print(lst)>>> [0,1,2,3,4,5,6,7,8,9]# 倒序排序lst = [4,3,2,5,7,8,9,1,6,0]lst.sort(reverse=True)print(lst)>>> [9,8,7,6,5,4,3,2,1,0]# 翻转lst = [4,3,2,5,7,8,9,1,6,0]lst.reverse()print(lst)>>> [0,6,1,9,8,7,5,2,3,4]#---------------------------------------# 列表的嵌套lst = ['C','Java','C++','Python','Ruby','PHP',['HTML','GO','R','Objective-C']]# 需求：将"HTML"改为"JavaScript"lst[-1][0] = 'JavaScript'print(lst)# 需求：将"PHP"改为"php"lst[5] = lst[5].lower()print(lst)#---------------------------------------# join()方法# S.join():其中S是字符串连接符，join中参数必须是可迭代对象，join()方法输出可迭代对象的每一个元素，并用连接符将每一个元素连接s = 'ilovepython'l = ['C','Java','C++','Ruby','PHP','Python']print('_'.join(s))>>> 'i_l_o_v_e_p_y_t_h_o_n'print('_'.join(l))>>> 'C_Java_C++_Ruby_PHP_Python'

4.3 公共方法

# 公共方法# 统计元素长度s = 'ilovepython'l = ['C','Java','C++','Ruby','PHP','Python','C','JAVA']print(len(s))>>> 11print(len(l))>>> 8# 统计元素出现的次数s = 'ilovepython'l = ['C','Java','C++','Ruby','PHP','Python','C','JAVA']print(s.count('o'))>>> 2print(l.count('C'))>>> 2# 输出指定元素的索引值s = 'ilovepython'l = ['C','Java','C++','Ruby','PHP','Python','C','JAVA']print(l.index('Java'))>>> 1print(s.index('e'))>>> 4

4.4 ★★★重要方法

# string <——> list : 字符串与列表的相互转换# string ——> list : split()s = 'i_l_o_v_e_p_y_t_h_o_n'print(s.split('_'))>>> ['i', 'l', 'o', 'v', 'e', 'p', 'y', 't', 'h', 'o', 'n']# list ——> string : join()l = ['C','Java','C++','Ruby','PHP','Python']print(''.join(l))>>> CJavaC++RubyPHPPython

4.4.1 range()方法

# range:相当于都是数字的列表 [0,1,2,3,4.....,99]# range(起始值，终止值)for i in range(0,100):    print(i)# 默认起始值不写默认为0for i in range(100):    print(i)# 同索引一样，range也可以加步长,加步长的话默认的0起始值就不可以省略for i in range(0,100,2):    print(i)for i in range(100,0,-2):    print(i)

4.4.2 enumerate()方法

# 枚举。对于一个可迭代的(iterable)/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。lst = ['python','java','c','ruby','Go']for i in enumerate(lst):    print(i)>>> (0, 'python')>>> (1, 'java')>>> (2, 'c')>>> (3, 'ruby')>>> (4, 'Go')for index, name in enumerate(lst, 1):    print(index, name)>>> 1 python>>> 2 java>>> 3 c>>> 4 ruby>>> 5 Gofor index, name in enumerate(lst, 100):  # 起始位置默认是0，可更改    print(index, name)　>>> 100 python>>> 101 java>>> 102 c>>> 103 ruby>>> 104 Go

4.4.3 ★深浅拷贝 copy()、deepcopy()

①原理讲解及测试

# 普通赋值运算lst_1 = ['Python','Java',['Ruby','PHP','C++']]lst_2 =lst_1 # lst_2 = lst_1[:] 同理print(lst_1)print(id(lst_1))print('*'*10)print(lst_2)print(id(lst_2))>>> ['Python','Java',['Ruby','PHP','C++']]>>> 18623368>>> **********>>> ['Python','Java',['Ruby','PHP','C++']]>>> 18623368# 浅copy()方法：第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。lst_1 = ['Python','Java',['Ruby','PHP','C++']]lst_2 =lst_1.copy() # lst_2 = lst_1[:] 同理lst_1[2].append('new_lanuage')print(lst_1,id(lst_1))print('*'*10)print(lst_2,id(lst_2))>>> ['Python', 'Java', ['Ruby', 'PHP', 'C++', 'new_lanuage']] 12001800>>> **********>>> ['Python', 'Java', ['Ruby', 'PHP', 'C++', 'new_lanuage']] 12015048# 深copy()方法：对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。import copylst_1 = ['Python','Java',['Ruby','PHP','C++']]lst_2 = copy.deepcopy(lst_1)lst_1[2].append('new_lanuage')print(lst_1,id(lst_1))print('*'*10)print(lst_2,id(lst_2))>>> ['Python', 'Java', ['Ruby', 'PHP', 'C++', 'new_lanuage']] 12533000>>> **********>>> ['Python', 'Java', ['Ruby', 'PHP', 'C++']] 12533512

5、tuple(元组类型)

5.1 介绍

Python的元组与列表类似，同样可通过索引访问，支持异构，任意嵌套。不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

5.2 常用方法

Tuple与List方法相同，不同在于元组不能更改

6、dict(字典类型)

6.1 介绍

6.1.1 字典介绍

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

6.1.2数据类型划分：可变数据类型、不可变数据类型

1. 不可变数据类型：元组、布尔值、数值、字符串 ——> 不可变数据类型又称为可哈希
2. 可变数据类型：列表、字典、集合 ——>不可哈希

6.1.3 字典的特性

1. 字典dict的key必须是不可变数据类型：元组、布尔值、数值、字符串
2. 字典dict的value可以是任意数据类型
3. 字典dict的优点：
   
   • 二分查找查询
   • ②存储大量的关系型数据
4. 字典的特点：
   
   • 无序的——>无索引（python3.5及以前版本）

6.2 常用方法

dic = {'age': 26, 'name': 'yang', 'sex': 'male'}# --------------------------------------------------------------------------# 增 - 2种dic['height'] = 180 # 如果没有键，则增加>>> {'age': 26, 'name': 'yang', 'sex': 'male','height':180}dic['age'] = 18 # 如果有键，则覆盖>>> {'age': 18, 'name': 'yang', 'sex': 'male'}dic.setdefault('height') # 如果没有键，则增加，且如果不写值vlaue，则默认None>>> {'age': 26, 'name': 'yang', 'sex': 'male','height':None}dic.setdefault('height', 185) # 如果没有键，则增加>>> {'age': 26, 'name': 'yang', 'sex': 'male','height':185}dic.setdefault('age', 185) # 如果有键，不覆盖>>>{'age': 26, 'name': 'yang', 'sex': 'male'}# --------------------------------------------------------------------------# 删 - 4种# ①dic.pop('name1','No KEY') # 如果有没键，不报错，返回值会返回后面的参数文本>>> print(dic.pop('name1','No KEY'))>>> 'No KEY'>>> print(dic)>>> {'name': 'yang', 'sex': 'male', 'age': 26}dic.pop('age') # 如果有键,则删除对应的键值对；返回值会返回删除掉的值value>>> print(dic.pop('age'))>>> 26print(dic)>>> {'sex': 'male', 'name': 'yang'}# ②dic.popitem() # 随机删除字典中的一组键值对>>> {'name': 'yang', 'sex': 'male'}# ③del dic['height'] # 如果没有键，则报错>>> Traceback (most recent call last):      File "D:/python_fullstack_s9/day5/day5_课堂内容总结.py", line 31, in <module>        del dic['height'] # 如果没有键，则报错    KeyError: 'height'del dic['age'] # 如果有键，则删除对应的键值对>>> {'name': 'yang', 'sex': 'male'}# ④dic.clear() # 清空字典>>> {}# --------------------------------------------------------------------------# 改 - 2种# ①dic['height'] = 185 # 如果没有键，则增加>>> {'height': 185, 'age': 26, 'sex': 'male', 'name': 'yang'}dic['age'] = 18 # 如果有键，则修改>>> {'sex': 'male', 'name': 'yang', 'age': 18}# ②dic_new = {'lanuage':'PYTHON','addr':'昌平'}dic.update(dic_new) # update(dict)，update的参数必须是键值对，将dic_new所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic中>>> {'sex': 'male', 'addr': '昌平', 'lanuage': 'PYTHON', 'name': 'yang', 'age': 26}# --------------------------------------------------------------------------# 查 - 5种# ①dic.keys() # 获取字典的键，返回dict.keys的数据类型，相当于list默认打印字典的键for i in dic1:    print(i)for i in dic1.keys():    print(i)# ②dic.values() # 获取字典的值，返回dict.values的数据类型，相当于list默认打印字典的值for i in dic1.values():    print(i)# ③dic.items() # 获取字典的键和值，返回由keys和values组成的元组默认打印字典的键值for i in dic1.items():    print(i)for keys,values in dic1.items():    print(keys,values)# ④dic.get('height','No KEY') # 如果没有键，则返回值为后面的参数文本print(dic.get('height','No KEY'))>>> No KEYdic.get('age','No KEY') # 如果有键，则返回值为对应键的值print(dic.get('age','No KEY'))>>> 26# ⑤print(dic['height']) # 如果有没键，则报错>>> Traceback (most recent call last):      File "D:/python_fullstack_s9/day5/day5_课堂内容总结.py", line 79, in <module>        print(dic['height']) # 如果有没键，则报错    KeyError: 'height'print(dic['age']) # 如果有键，则返回键对应的值>>> 26# --------------------------------------------------------------------------# 字典的嵌套dic = {    'name':['a','b','c'],    'age':43,    'addr':{        '1':1,        '2':2,    }}# 需求：在addr中加入'3':3这个键值对dic['addr']['3'] = 3print(dic)

7、set(集合类型)

7.1 介绍

7.1.1 集合介绍

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
1. 去重，把一个列表变成集合，就自动去重了。
2. 关系测试，测试两组数据之前的交集、差集、并集等关系。

7.2 常用方法

# 集合# 增 - 2种set1 = {'a', 'b', 'c', 'd'}set1.add('e')print(set1)>>> {'a', 'c', 'd', 'e', 'b'}set_new = {'A','B','C','D'}set1.update(set_new)print(set1)>>> {'b', 'C', 'B', 'c', 'a', 'A', 'D', 'd'}# 删 - 4种set1 = {'a', 'b', 'c', 'd'}set1.pop()print(set1)>>> {'d', 'c', 'b'}set1.remove('c')print(set1)>>> {'d', 'b', 'a'}set1.clear()print(set1)>>> set()del set1print(set1)>>>Traceback (most recent call last):      File "D:/python_fullstack_s9/day7/practice.py", line 160, in <module>        print(set1)    NameError: name 'set1' is not defined# 查 - 6种set1 = {'a', 'b', 'c', 'd'}for i in set1:    print(i)>>> d>>> a>>> c>>> b# ①交集set1 = {'a', 'b', 'c', 'd', '1', '4'}set2 = {'1', '2', '3', '4', 'b', 'c'}print(set1 & set2)>>> {'c', '4', '1', 'b'}print(set1.intersection(set2))>>> {'c', '4', '1', 'b'}# ②反交集set1 = {'a', 'b', 'c', 'd', '1', '4'}set2 = {'1', '2', '3', '4', 'b', 'c'}print(set1 ^ set2)>>> {'d', '2', 'a', '3'}print(set1.symmetric_difference(set2))>>> {'d', '2', 'a', '3'}# ③并集set1 = {'a', 'b', 'c', 'd', '1', '4'}set2 = {'1', '2', '3', '4', 'b', 'c'}print(set1 | set2)>>> {'1', 'b', '2', '3', 'c', 'd', '4', 'a'}print(set1.union(set2))>>> {'1', 'b', '2', '3', 'c', 'd', '4', 'a'}# ④差集set1 = {'a', 'b', 'c', 'd', '1', '4'}set2 = {'1', '2', '3', '4', 'b', 'c'}print(set1 - set2)>>> {'d', 'a'}print(set1.difference(set2))>>> {'d', 'a'}print(set2 - set1)>>> {'2', '3'}print(set2.difference(set1))>>> {'2', '3'}# ⑤子集与超集set1 = {'A','B','C','a','b','c'}set2 = {'A','B','C'}print(set2 < set1)>>> Trueprint(set2.issubset(set1))>>> Trueprint(set1 > set2)>>> Trueprint(set1.issuperset(set2))>>> True# ------------------------------------------------------------# 不可变集合set_frozen = frozenset({'A', 'B', 'C'})print(set_frozen)>>> frozenset({'C', 'B', 'A'})