要懂Python的话，这些最基础的你不能不会

基础数据类型

int str bool dict tuple list set

1.int数字类型

int(3)>>>3
int(3.6)>>>3 #取整
int(“1101”,2)>>>13 #二进制转换十进制
int类型多用于计算

2.str字符串

Python中凡是用引号引起来的数据可以称为字符串类型，组成字符串的每个元素称为字符，将这些字符一个一个链接起来，然后在用引号引起来就是字符串。
程序一般都是和数据打交道，大量的数据存储在数据库，缓存，文件等，但是程序需要将这些数据提取出来，处理，加工，这些提取出来的数据，在程序中往往是以字符串的形式存在，字符串一般存储一些相对少量的数据。

a1 = "abc"
#对于这个a1这个字符串来说，它由三个字符组成：a,b,c

2.1字符串的索引与切片

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

a = "abcd"
print(a[0])   ----- a
print(a[3])   ------d

切片就是通过索引(步长）截取字符串的一段，形成新的字符串(原则就是顾头不顾腚)

a = 'ABCDEFGHIJK'
print(a[0:3])  # print(a[:3]) 从开头开始取0可以默认不写
print(a[2:5])
print(a[:]) #默认到最后
print(a[:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[:5:2]) #加步长
print(a[-1:-5:-2]) #反向加步长

b = a[i:j] 表示复制a[i]到a[j-1]，以生成新的list对象

a = [0,1,2,3,4,5,6,7,8,9]

b = a[1:3] # [1,2]

当i缺失时，默认为0，即 a[:3]相当于 a[0:3]

当j缺失时，默认为len(alist), 即a[1:]相当于a[1:10]

当i,j都缺失时，a[:]就相当于完整复制一份a

b = a[i:j:s]表示：i,j与上面的一样，但s表示步长，缺失为1.

所以a[i:j:1]相当于a[i:j]

当s<0时，i缺失时，默认为-1. j缺失时，默认为-len(a)-1

所以a[::-1]相当于 a[-1:-len(a)-1:-1]，也就是从最后一个元素到第一个元素复制一遍，即倒序

2.2字符串常用的一些方法

capitalize 创建一个首字母大写，其余字母小写的新字符串
s1="aBCd"   s1.capitalize------"Abcd"

swapcase 创建一个大小写翻转的新字符串

upper 返回一个全部大写的新字符串

lower :创建一个全部变小写新的字符串

casefold 返回一个新的字符串全部为小写，与lower相似，但是lower只能转换ASCCI码中的字母，而此方法可以转换非中文的其他语言，比如德语，葡萄牙语等。

find 从左边开始通过元素找索引（可切片），找到第一个元素就返回，找不到该元素返回-1

index 通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错

count 计算某个元素出现的次数

strip 创建一个新的字符串：默认去除原字符串前后两端的换行符，制表符，空格，一般多用在input()后面
name=input("请输入你的名字:").strip()

split 返回一个列表：默认以空格分割,可指定分隔符，可设置分割次数 str>>>list(将字符串转化为列表)
s1 = "a,b,c|d"    s1.split(",")----------["a","b","c|d"]

join (list ---> str)(这个方法非常好，不只是将list转化成str这一个功能） 返回一个字符串：对iterable进行遍历，通过你设置的连接符将iterable的每个元素通过你的连接符连接起来形成一个新的字符串)
s1 = ["a","b","c"]  "|".join(s1)---------"a|b|c"

replace 创建一个新的字符串，将原字符串中的选择内容替换成设置的内容，默认全部替换，可以设置替换次数。
s1 = "aacdefg"  s1.replace("a","b",1)-------"bacdefg"

format 格式化输出 现在多用f""了

encode 将字符串转化成bytes类型，默认转化成utf-8的bytes类型，可设置。

decode 将bytes类型转化为字符串可设置，默认转化成utf-8的字符串

center 创建一个新字符串；字符串居中，可以设置字符串的长度，并切可以设置填充物
s1 = "abc" s1.center(3,'*')----------"***abc***"

startswith 判断该字符串以某个字符或者某些字符为开头，并且可以切片，返回的是bool值
s1 = "abc"   s1.startswith("a")------------True

endswith 判断该字符串以某个字符或者某些字符为结尾，并且可以切片，返回的是bool值

isalpha 判断字符串是否全部由字母组成,返回boor值，中文也识别

isdecimal 判断字符串全部都是阿拉伯数字组成，返回boor值

isalnum 检测改字符串是否由数字或者字母组成。返回bool值

3.list列表

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

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

3.1列表的创建

# 创建一个列表有三种方式：

# 方式一：（常用）
l1 = [1, 2, '太白']


# 方式二：（不常用）
l1 = list()  # 空列表
# l1 = list(iterable)  # 可迭代对象（不可变的数据类型）
l1 = list('123')
print(l1)  # ['1', '2', '3']

# 方式三：列表推导式 可加判断
l1 = [i for i in range(1,5)]
print(l1)  # [1, 2, 3, 4]

3.2列表的索引切片

l = ['太白', [1, 2, 3, ], 'WuSir', '女神']
print(l[1]) # [1, 2, 3]
print(l[-1]) # '女神'
print(l[1:3]) # [[1, 2, 3], 'WuSir']
print(l[::2]) # ['太白', 'WuSir']
print(l[-1:-4:-1]) # ['女神', 'WuSir', [1, 2, 3]]

3.3列表的相关方法

3.3.1增

# append 追加，给列表的最后面追加一个元素
l = [1, 2, 'a']
l.append(666)
print(l) # [1, 2, 'a', 666]

# insert  插入在列表的任意位置插入元素
l = [1, 2, 'a']
l.insert(1,'太白')
print(l) # [1, '太白', 2, 'a']

# extend  迭代着追加，在列表的最后面迭代着追加一组数据
l = [1, 2, 'a']
l.extend('太白a')
print(l)       #[1,2,"a","太","白","a"]

3.3.2删

# pop  通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素
l = ['太白', 'alex', 'WuSir', '女神']
ret = l.pop(1)
print(ret,l) # alex ['太白', 'WuSir', '女神']

# remove  通过元素删除列表中该元素
l = ['太白', 'alex', 'WuSir', '女神']
l.remove('alex')
print(l) # ['太白', 'WuSir', '女神']

# clear 清空列表
l = ['太白', 'alex', 'WuSir', '女神']
l.clear()
print(l) # []  

# del
#按照索引删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[2]
print(l) # ['太白', 'alex', '女神']

# 切片删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[1:]
print(l) # ['太白']

# 切片(步长)删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[::2]
print(l) # ['alex', '女神']

3.3.3改

# 按照索引改值
l = ['太白', 'alex', 'WuSir', '女神']
l[0] = '男神'
print(l) # ['男神', 'alex', 'WuSir', '女神']

# 按照切片改值(迭代着增加)
l = ['太白', 'alex', 'WuSir', '女神']
l[1:3] = 'abcdefg'
print(l) # ['太白', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '女神'] 

# 按照切片(步长)改值(必须一一对应)
l = ['太白', 'alex', 'WuSir', '女神']
l[::2] = '对应'
print(l) # ['对', 'alex', '应', '女神']

3.3.4查

# 按照索引去查看

# 按照切片(步长)去查看

# for 循环查看
l = ['太白', [1, 2, 3, ], 'WuSir', '女神']
for i in l:
print(i)   

3.3.5其他方法

index 通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错
s1 =["a","b"]  s1.index("a") ------0

count 返回某元素在列表中出现的次数

sort 默认从小到大排列，设置参数后可从大到小排列sort(reverse=Ture)
l = [7, 4, 8, 9, 1, 2, 3, 5, 6]
l.sort()
print(l) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

reverse 反转列表,将列表中元素全部翻转

copy 浅copy 列表的壳子是新的id(内存中存放的地址名称)但是里面的元素内容id是跟原来一样的
s1 = [[1,2,3],"a"]
s2 = s1.copy()  --------[[1,2,3],"a"]
s2[0][1] = 3 此时改的是s2中嵌套列表中的数据,但是因为id相同所以s1这个列表也被改变了,因为共用的是一个id地址
s2 -------[[3,2,3],"a"]
s1 -------[[3,2,3],"a"] 

列表可以相加和与整数相乘
l1 = [1, 2, 3]
l2 = [4, 5, 6]
# print(l1+l2)  # [1, 2, 3, 4, 5, 6]
print(l1*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

4.tuple元组

对于容器型数据类型list，无论谁都可以对其增删改查，那么有一些重要的数据放在list中是不安全的，所以需要一种容器类的数据类型存放重要的数据，创建之初只能查看而不能增删改，这种数据类型就是元组。

元组:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改。

当程序中需要设置一些重要的数据，这些数据不想让其他人更改，只能查看时，可以将数据存放在元组中。

4.1元组的索引切片

tu1 = ('a', 'b', '太白', 3, 666)
print(tu1[0])  # 'a'
print(tu1[-1])  # 666
print(tu1[1:3])  # ('b', '太白')
print(tu1[:-1])  # ('a', 'b', '太白', 3)
print(tu1[::2])  # ('a', '太白', 666)
print(tu1[::-1])  # (666, 3, '太白', 'b', 'a')

4.2元组的相关方法

因为元组的特性，直接从属于元组的元素不能更改，只能查看，但是要注意下面的情况

tu = (1, '太白', ['alex', ])
# 元组为只读列表，不能增删改其值，只能查，但是对于改来说是相对的。
# 直接属于元组的元素不能改，但是间接属于元组的元素不一定，比如上面的alex就不是直接从属于元组的元素,它直接从属于的是列表list。
# 举个不恰当的例子：儿子不能改，孙子可以改。
tu[-1][0] = '日天'
print(tu) -----------（1,"太白",["日天",]）

index 通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错
tu = ('太白', [1, 2, 3, ], 'WuSir', '女神')
print(tu.index('太白')) ---------- 0

count 获取某元素在列表中出现的次数
tu = ('太白', '太白', 'WuSir', '吴超')
print(tu.count('太白')) -----------2

5.dict字典

由于列表存储数据量太大的话查询速度就会下降和列表只能按照顺序储存，数据与数据之间关联性不强所以就要引入另外一种容器型数据类型dict

字典是Python语言中的映射类型，他是以{}括起来，里面的内容是以键值对的形式储存的：

Key（键）: 不可变（可哈希）的数据类型.并且键是唯一的，不重复的。
Value（值）:任意数据(int，str，bool，tuple，list，dict，set)，包括实例对象等。

在Python3.5版本（包括此版本）之前，字典是无序的。
　在Python3.6版本之后，字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。

缺点：内存占用大

字典查询速度之所以快的（简单）解释：
字典的键值对会存在一个散列表（稀疏数组）这样的空间中，每一个单位称作一个表元，表元里面记录着key：value,如果你想要找到这个key对应的值，先要对这个key进行hash获取一串数字咱们简称为门牌号（非内存地址），然后通过门牌号，确定表元，对比查询的key与被锁定的key是否相同，如果相同，将值返回，如果不同，报错。（这里只是简单的说一下过程，其实还是比较复杂的。）

5.1字典的创建

# 创建字典的几种方式：

# 方式1:
dic = dict((('one', 1),('two', 2),('three', 3)))
# dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic)  # {'one': 1, 'two': 2, 'three': 3}


# 方式2:
dic = dict(one=1,two=2,three=3)
print(dic)  # {'one': 1, 'two': 2, 'three': 3}


# 方式3:
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic)  # {'one': 1, 'two': 2, 'three': 3}

# 方式5: 
dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
print(dic)

# 方式6: 字典推导式 
# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
# print(dic)

# 方式7:利用fromkeys 可以是可迭代对象
# dic = dict.fromkeys('abcd','太白')
# print(dic)  # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}

5.2字典的合法性(创建的规则)

# 合法 key只能是不可变类型 str tuple True False int
dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帅
哥', '美⼥'], (1, 2, 3): '麻花藤'}


# 不合法
# dic = {[1, 2, 3]: '周杰伦'} # list是可变的. 不能作为key
# dic = {{1: 2}: "哈哈哈"} # dict是可变的. 不能作为key
dic = {{1, 2, 3}: '呵呵呵'} # set是可变的, 不能作为key

5.3字典的相关方法

5.3.1增

# 通过键值对直接增加
dic = {'name': '太白', 'age': 18}
dic['weight'] = 75 # 没有weight这个键，就增加键值对
print(dic) # {'name': '太白', 'age': 18, 'weight': 75}
dic['name'] = 'barry' # 有name这个键，就成了字典的改值
print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}

# setdefault
dic = {'name': '太白', 'age': 18}
dic.setdefault('height',175) # 没有height此键，则添加
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
dic.setdefault('name','barry') # 有此键则不变
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
#它有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.setdefault('name')
print(ret)  # 太白

# update
dic = {'name': '太白', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': '太白', 'age': 18, 'sex': '男', 'height': 175}

dic = {'name': '太白', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '太白', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}

dic1 = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75}

5.3.2删

# pop 通过key删除字典的键值对，有返回值，可设置返回值。
dic = {'name': '太白', 'age': 18}
# ret = dic.pop('name')
# print(ret,dic) # 太白 {'age': 18} 返回值为你删除的key的value，如果没有设置返回值就删除的话会报错
ret1 = dic.pop('n',None)
print(ret1,dic) # None {'name': '太白', 'age': 18}

#popitem 3.5版本之前，popitem为随机删除，3.6之后为删除最后一个，有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.popitem()
print(ret,dic) # ('age', 18) {'name': '太白'}

#clear 清空字典
dic = {'name': '太白', 'age': 18}
dic.clear()
print(dic) # {}

# del
# 通过键删除键值对
dic = {'name': '太白', 'age': 18}
del dic['name']
print(dic) # {'age': 18}
#删除整个字典
del dic

5.3.3改

# 通过键值对直接改
dic = {'name': '太白', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': 'barry', 'age': 18}

5.3.4查

# 通过键查询
# 直接dic[key](没有此键会报错)
dic = {'name': '太白', 'age': 18}
print(dic['name']) # 太白

# get 可以设置如果没有此键的时候的返回值
dic = {'name': '太白', 'age': 18}
v = dic.get('name')
print(v) # '太白'
v = dic.get('name1')
print(v) # None
v = dic.get('name2','没有此键')
print(v) # 没有此键 


keys()
dic = {'name': '太白', 'age': 18}
print(dic.keys()) # dict_keys(['name', 'age']) 

values()
dic = {'name': '太白', 'age': 18}
print(dic.values()) # dict_values(['太白', 18])

items()
dic = {'name': '太白', 'age': 18}
print(dic.items()) # dict_items([('name', '太白'), ('age', 18)])

5.3.5其他操作–延伸

keys values items copy(也是浅copy)

dic = {'剑圣':'易','剑豪':'哈啥给','盖伦':'大宝剑'}
key_list = dic.keys()    
print(key_list)

结果:
dict_keys(['剑圣', '剑豪', '盖伦'])
# 一个高仿列表,存放的都是字典中的key

# 并且这个高仿的列表可以转化成列表
print(list(key_list))

# 它还可以循环打印

dic = {'剑圣':'易','剑豪':'哈啥给','盖伦':'大宝剑'}
for i in dic:
    print(i)

value_list = dic.values()
print(value_list)

结果:
dict_values(['易', '哈啥给', '大宝剑'])
#一个高仿列表,存放都是字典中的value
# 并且这个高仿的列表可以转化成列表
print(list(value_list))

# 它还可以循环打印
for i in dic.values():   
    print(i)


key_value_list = dic.items()
print(key_value_list)
结果:
dict_items([('剑圣', '易'), ('哈啥给', '剑豪'), ('大宝剑', '盖伦')])

# 一个高仿列表,存放是多个元祖,元祖中第一个是字典中的键,第二个是字典中的值　　

# 并且这个高仿的列表可以转化成列表
print(list(key_value_list ))

# 它还可以循环打印
dic = {'剑圣':'易','剑豪':'哈啥给','盖伦':'大宝剑'}
for i in dic.items():
    print(i)
结果：
('剑圣', '易')
('剑豪', '哈啥给')
('盖伦', '大宝剑')

#拆包
a,b=1,2
print(a,b) ---------1  2
for k,v in dic.items():
    print('这是键',k)
    print('这是值',v)

结果:
这是键 剑圣
这是值 易
这是键 剑豪
这是值 哈啥给 
这是键 盖伦
这是值 大宝剑 

字典的嵌套

dic = {
    'name':'汪峰',
    'age':48,
    'wife':[{'name':'国际章','age':38}],
    'children':{'girl_first':'小苹果','girl_second':'小怡','girl_three':'顶顶'}
}
# 获取这个字典：{'name':'国际章','age':38}
di = dic['wife'][0]

# 获取汪峰的第三个孩子名字
name = dic['children']['girl_three']

当程序需要设置大量的关系型数据类型，并且要求查询速度时，需要考虑字典

6.bool(布尔值)

当程序中需要判断等式或者不等式的对错，作为if或者while等判断条件真假时。

布尔值就两种: True, False。就是反应条件的正确与否
真 1 True
假 0 False

注意： [], {} , “” , None , () , set()—空集合 , 0 boor都是False

7set集合(不常用)

跟列表相似，但是里面的元素是没有顺序的，并且不能有重复的元素(可以用来列表去重, 虽然是乱序)

多用于列表去重和关系测试(交集，差集，并集，差集，反交集，子集与超集)

7.1去重

lis=[1,1,2,3,3]
lis1=list(set(lis))   结果为乱序的去重列表lis

7.2交集与并集与差集

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

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

# 差集
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}

终于复习完基础数据类型了，难道就我感觉都忘了差不多了¿ 我枯了o(╥﹏╥)o