基本数据类型

数字类型

• 只能存取一个值
• 数字是不可变类型，根据id来看，不可变类型是可hash
• 数字主要是用来计算的，使用方法不是很多，记住如下一种

1.整数类型(int)当十进制用二进制来表示的时候，最少使用的位数

age = 18
print(age.bit_length())

2.浮点型(float)身高,体质参数,体重

salary = 3.1   #salary = salary(3.1)
print(salary,type(salary))

3.复数(complex)

x = 1 + 2j
print(x.real)
print(x.imag)
print(type(x))

布尔值(bool)

• 布尔值,只有两种一种是True,一种是False

真为：True
假为：False
在数字中：只有0为False，其余为True
在字符串中：只有空为False，其余为True

字符串(str)

• 字符串只有一个值
• 字符串是有序的
• 不可变类型，可被hash

1.索引
字符串是有序的，可以按照索引取值

name = "tianjianyu"
print(name[0])   #取第一个值
print(name[-1])  #取最后一个值

2.切片就是通过[索引：索引：步长]取字符串的一段，行成一段新的字符串，原则是顾头不顾尾

name = "tianjianyu"
print(name[0:4])     #比如取tian字符串,t为0，n为3，但是切片顾头不顾尾，需要3的位置在加1位，才能取到tian
print(name[0:4:1])   #这个1为步长，默认为1，也可以自己指定
print(name[:])       #初始位置不写,最后位置也不写，取的是该字符串的全部
print(name[::-1])    #初始位置不写,最后位置也不写,但是步长为-1，相当于将整个字符串翻转

3.captalize,swapcase,title

str_1 = "tianjianyu"
print(str_1.capitalize()) #首字母大写
str_2 = "Tian Jian Yu"
print(str_2.swapcase())   #大小写翻转
str_3 = "tian jian yu"
print(str_3.title())   #每个字母的首字母大写
str_4 = "tianjianyu"
print(str_4.upper())  #将字符串的所有字母转换为大写
str_5 = "TIANJIANYU"
print(str_5.lower())   #将字符串所有字母转换为小写

4.”center”用于填充，比如需要长度为20,name会居中，总长度为20,用空格填充

name = "tian"
print(name.center(20))

5.expandtabs

# name='egon\thello'
# print(name.expandtabs(10))
"""
S.expandtabs(tabsize=8) -> str

        Return a copy of S where all tab characters are expanded using spaces.
        If tabsize is not given, a tab size of 8 characters is assumed.
        1.expandtabs后边的参数为几就把几个分在一起；
        比如为2，那么就两个一组，前边如果有一个了，就在补充一个；
        反之，如果两个一组前边一个没有，那么就补充两个空格
"""

6.find,index

name = "hello world"
print(name.find("o",0,4))  #顾头不顾尾，找到则返回索引位置，找不到则返回-1
print(name.index("o",0,4)) #和find一样，但是找不到会报错substring not found

7.count用于统计某个元素的个数

name = "hello"
print(name.count("l"))

8.split将一个字符串以什么切割，行成一个新的列表

name = "tian jian yu"
print(name.split())

9.join的用法，用于字符串的拼接,将一个列表拼接成一个字符串，只有在列表内的所有元素都是字符串才可以拼接

name = ["tian","jian","yu"]
print(" ".join(name))

9.format格式化的方法

print("my name is {} age is {}".format("tian",18))
print("my name is {name} age is {age}".format(name="tian",age=18))

10.replace将字符串中的元素进行替换，如果不重新赋值，字符串是不可变类型

msg = "hello"
print(msg.replace("l","d",1))

11.isalnum,isdigit,isalpha判断字符串的组成

name='tianjianyu123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成

元祖(tuple)

• 元组适用于不变的数据
• 元组是有序的
• 元组是不可变类型(但是元组可以对嵌套的列表内的元素修改)

1.定义：

age = (1,2,3,4)
print(age,type(age))

2.索引取值

age = (1,2,3,4)
print(age[1])

3.切片

age = (1,2,3,4)
print(age[0:3])

4.根据元素找索引位置

age = (1,2,3,4)
print(age.index(1))

5.count统计某个元素出现的次数

age = (1,2,3,4)
print(age.index(1))

列表(list)

• 存一个值或者多个值，值为任意类型
• 有序，可以按照索引取值
• 可变类型

1.定义方式，”[]”内可以有多个任意类型的值，用”,”分割

name = ["tian","jian","yu",1,2,3]  #本质name = list([...])
print(list("hello"))    #传个字符串的方式

2.索引取值

name = ["tian","jian","yu",1,2,1]
print(name[1])

3.切片顾头不顾尾

name = ["tian","jian","yu",1,2,1]
print(name[0::1])      #取全部列表，步长为1
print(name[-1::-1])    #反向去列表全部，类似revers功能

4.增：insert,append,extend

name = ["tian","jian","yu"]
name.insert(0,"qudi")    #insert指定索引位置添加，如果指定的索引不存在,则在最后添加
name.append("tianjianyu") #增加到最后
name.extend("abc")        #迭代的去增加
print(name)  #最后打印结果为：['qudi', 'tian', 'jian', 'yu', 'tianjianyu', 'a', 'b', 'c']

5.删：pop,del,remove,clear

name = ["tian","jian","yu"]
name.pop(0)   #按照索引去删，返回值为删掉的元素
name.remove("tian")   #按照元素去删除。返回值为None，拿不到结果
name.clear()     #清空列表
del name[0:1]   #按照位置去删除，也可切片删除没有返回值

6.改

name = ["tian","jian","yu"]
name[0] = "qudi"       #将索引0位置替换为qudi
name[1:2] = ["a","b"]   #按照切片去替换
print(name)             #['qudi', 'a', 'b', 'yu']

7.查index,切片，for循环

name = ["tian","jian","yu"]
print(name.index("tian"))    #按照元素查找返回索引位置

name = ["tian","jian","yu"]
for i in name:              #使用for循环查
    print(i)

8.count统计某个元素出现的次数

name = ["tian","jian","yu","tian"]
print(name.count("tian"))

9.sort,reverse

a = [5,6,8,9,1,2]
a.sort()
print(a)   #[1, 2, 5, 6, 8, 9]正序

a = [5,6,8,9,1,2]
a.sort(reverse=True)
print(a)   #[9, 8, 6, 5, 2, 1]倒序

a = [5,6,8,9,1,2]
a.reverse()
print(a)   #[2, 1, 9, 8, 6, 5]整个列表翻转  

字典(dict)

• 按照key：value，存取速度快，可以是任意类型,key必须是不可变类型
• 3.6版本以前是无序的，3.6以后是有序的，有序不是可以按照索引取值
• 可变

1.增

dic = {"name":"tianjianyu","age":24}
dic["hobbies"] = "gril"    #增加一对key，val如果key有则将val的值赋值成新的，没有则添加一对新的key，val
dic["name"] = "qudi"
print(dic)

dic = {"name":"tianjianyu","age":24}
dic.setdefault("name")     #在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖
dic.setdefault("hobbies")
print(dic)

2.删：pop,popitem,clear,del

name_dict  = {"name":"qudi","age":18}
print(name_dict.pop("name"))   #pop传key值可以返回值
print(name_dict.popitem())     #删除一对键值对，返回值为元祖
print(name_dict)
print(name_dict.clear())  # 清空字典，没有返回值
del name_dict   #删除整个字典

3.改

dic = {"name":"tianjianyu","age":24}
dic["name"] = "qudi"   #取到key值之后重新赋予新值

dic1 = {"name":"tianjianyu","age":24}
dic2 = {"name":"qudi","age":25,"hobbies":"boy"}
dic1.update(dic2)   #将dic2所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic1中
print(dic1)         #{'name': 'qudi', 'age': 25, 'hobbies': 'boy'}

4.查

dic = {"name":"tianjianyu","age":24}
dic1 = dic["hobbies"]     #如果没有该key值会报错,KeyError: 'hobbies'
print(dic1)

dic = {"name":"tianjianyu","age":24}
dic1 = dic.get("name")  #没有该key，不会报错，可以返回自定义的返回值，有则返回val值
print(dic1)

5.keys,values,items

dic = {"name":"tianjianyu","age":24}
print(dic.keys())                      #以类似元组的形式返回所有的key,dict_keys(['name', 'age'])
print(dic.values())                    #以类似元组的形式返回所有的val,dict_values(['tianjianyu', 24])
print(dic.items())                     #以类似元组的形式返回一对key,val,dict_items([('name', 'tianjianyu'), ('age', 24)])

6.字典的循环

dic = {"name":"tianjianyu","age":24}
for key in dic.keys():          #dic后边不写,默认是key
    print(key)
for val in dic.values():
    print(val)
for key,val in dic.items():    #
    print(key,val)

7.字典fromkeys用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print(dict)

集合

• 作用：关系运算，去重{}号内可以用逗号分隔，每个元素必须是不可变类型（不可hash）
• 集合内的元素不能重复
• 无序，不能按照索引取值

1.交集&两个集合相同的数字，不同的数字去掉

set_1 = {1,2,3,4}
set_2 = {1,3,4,5}
print(set_1&set_2)

2.合集|所有的数字，相同的数字去掉

set_1 = {1,2,3,4}
set_2 = {1,3,4,5}
print(set_1 | set_2)

3.对称差集，没有同时在两个列表中的数字

set_1 = {1,2,3,4}
set_2 = {1,3,4,5}
print(set_1 ^ set_2)

4.差集

set_1 = {1,2,3,4}
set_2 = {1,3,4,5}
print(set_1 - set_2)    #只存在set_1中的值
print(set_2 - set_1)    #只存在set_2中的值

5.父集

set_1 = {1,2,3,4}
set_2 = {1,2,3}
print(set_1 >= set_2)    #True,判断set_1是否包含set_2
print(set_2 >= set_1)    #False,判断set_2是否包含set_1

6.子集

set_1 = {1,2,3,4}
set_2 = {1,3,4}
print(set_1 <= set_2)   #False
print(set_2 <= set_1)   #True

注：
1.判断父集用>=,返回值为True，证明为父集
2.判断子集用<=，返回值为True,证明为子集
练习：
1.

l1 = [11, 22, 33, 44, 55]
将索引为奇数对应的元素删除。
del l1[1::2]  # 根据切片步长找出索引为奇数
print(l1)
for i in range(len(l1)):  # 循环列表时，不要改变列表的大小，否则会影响结果
    if i % 2 == 1:
        l1.pop(i)
print(l1)
for i in range(len(l1) - 1, -1, -1):  # 按照索引倒叙的方式删除，不会影响前边的列表顺序
    if i % 2 == 1:
        del l1[i]
print(l1)

2.

dic = {'k1': 'v1', 'k2': 'v2', 'k3':'v3', 'name':'alex'}
#删除字典中所有key中带有'k'的键值对
l1 = []
for i in dic:   
    if 'k' in i:   
        l1.append(i)   #循环一个字典时，不要改变字典的大小，否则会影响结果
for i in l1:
    del dic[i]
print(dic)

深浅copy

1.浅copy,外层是独立的，里边的是同一块内存空间

#1.
# list1 = [1,2,3]
# list2 = list1.copy()
# list1.append(4)
# print(list1,id(list1))
# print(list2,id(list2))
#2.切片的浅copy方法
# list1 = [1,2,3,[1,2,3]]
# list2 = list1[:]
# list1[-1].append(4)
# list1.append(4)
# print(list1,id(list1))
# print(list2,id(list2))

2.深copy

import copy
# s1 = [1, 2, 3,[11,22]]
# s2 = copy.deepcopy(s1)
# s1.append(666)
# print(s1, s2)

# s1 = [1, 2, 3,[11,22]]
# s2 = copy.deepcopy(s1)
# s1[-1].append(666)
# print(s1, s2)
# 深copy 无论多少层，都是互相独立的。