Python_基础数据类型

一，首先介绍一下变量

1. 变量是什么

在Python中，变量的概念基本上和初中代数的方程变量是一致的。

2. 变量命名规则

由数字、字母、下划线组成
不能以数字开头
要具有描述性
要区分大小写
禁止使用python的关键字(在pycharm中关键字变量字体颜色会改变)
不能使用汉字或拼音
变量的推荐写法

7.1 驼峰体(类名推荐驼峰)

7.2 下划线(官方推荐)

3. 常量

变量名大写就是常量。

二，基础数据类型介绍

1， int

数字类型，不可变，可哈希，用于比较和计算。
python3除法返回的是float,浮点数（小数）
不可变数据类型之一

2，bool

布尔值，用于判

True - 真

非空就是True，如：1，‘字符串’，[列表]，(元组,) 等数据类型不为空就是真，
False - 假

为空就是False，如：0，’’，[]，()

3，str

什么是字符串？

python只要是用引号（''，""，""""""）引起来的就是字符串

字符串用于存储少量数据，不可变数据类型之一。

str的索引、切片、步长

索引，index

注意：索引的时候不可以超出字符串的索引值。
切片

切片的时候可以超出索引值，顾头不顾尾。

print(变量名[起始位置：终止位置]) 顾头不顾尾

print(变量名[:]) # 默认是从头到尾
步长

决定查找的方向（+ -）

决定查找时查到的步子

步长默认为1

[起始位置：终止位置：步长]

例：

# 从左向右排a = "0123456"

# 从左向右排a = "-7-6-5-4-3-2-1"

a = "风yu雷dian"

print(a[4]) # ｄ

print(a[-4]) # a

name = "东方不败,火云邪神,未来战士,审判天使,钢铁大侠"

print(name[0:14:2])

# 东不,云神未战

print(name[-4:-6:-1])

# 钢,

print(name[-7:-12:-2])

# 天审士

print(name[::-1])

# 侠大铁钢,使天判审,士战来未,神邪云火,败不方东

字符串的方法

upper() —— 全部大写

name = "qwer"

a = name.upper()  # 全部大写

print(a)

print(name)

lower() —— 全部小写

name = "QWER"

a = name.lower()   # 全部小写

print(name)

print(a)

str.capitalize() —— 首字母大写
str.title() —— 每个单词的首字母大写
str.swapcase() —— 大小写转换，字符串中大变小，小变大

name = 'qwer,asdf'

a = name.capitalize()

print(name)

print(a)

b = name.title()

print(name)

print(b)

c = name.swapcase()

print(name)

print(c)

结果：

qwer,asdf

Qwer,asdf

qwer,asdf

Qwer,Asdf

qwer,asdf

QWER,ASDF

str.center(数字,“分割符号”) —— 居中，填充

st = '真帅！'

a = st.center(30,"-")

print(st)

print(a)

结果：

真帅！

-------------真帅！--------------

startswith(“判断字符”，索引开头，索引结尾) —— 以什么开头 – 返回的是布尔值

endswith(“判断字符”，索引开头，索引结尾) —— 以什么结尾 – 返回的是布尔值

name = "qwertyuiop"

print(name.startswith('e',2,3))  # 以什么开头 -- 返回的是布尔值

print(name.endswith("x",1,4))    # 以什么结尾 -- 返回的是布尔值

count(“字符”，索引) —— 统计，计数

name = "qwetyuitrewasdfgh"

print(name.count("w",8))      # 统计,计数 区分大小写，8为索引到位置，从左到右计数，默认搜索全部

结果：1

strip() —— 脱默认脱(脱头尾两端的空格,换行符\n,制表符\t)

pwd = " ez   "

a = pwd.strip()   # 脱 默认脱(脱头尾两端的空格,换行符\n,制表符\t)

print(a)

pwd = "qweruytreqw"

a = pwd.strip("qw")  # 去除头尾两端指定的内容,"al"不分顺序

print(a)

结果：

ez

eruytre

split() —— 分割(默认空格,换行符\n,制表符\t)

“分割符”.join(list) —— 拼接,将列表转换成字符串

name = "qwe_asd_cc_r"

a = name.split("_")        # 分割(默认空格,换行符\n,制表符\t)

print(a)

a = name.split("_",2)      # 指定分割次数

print(a)

结果：返回的是列表类型

['qwe', 'asd', 'cc', 'r']

['qwe', 'asd', 'cc_r']

lis = ['qwe', 'asd', 'cc_r']

b = ",".join(lis)

print(lis)

print(b)

结果：

['qwe', 'asd', 'cc_r']

qwe,asd,cc_r

replace() —— 全部替换

name = "weixiang,qwe,a,b,v,d,e"

a = name.replace(",",".")               # 全部替换

print(a)

a = name.replace(",",".",4)             # 指定替换的次数

print(a)

结果：

weixiang.qwe.a.b.v.d.e

weixiang.qwe.a.b.v,d,e

format"{}" —— 按照位置顺序进行填充

name = "{}今年:{}".format("儿子",18)    # 按照位置顺序进行填充

print(name)

name = "{1}今年:{0}".format("儿子",18)    # 按照索引进行填充

print(name) # 18今年：儿子

name = "{name}今年:{age}".format(name="儿子",age=18)    # 按照名字进行填充

print(name)

print(str.fimd(“元素”)) —— 查找通过元素查找索引,查找不到时返回-1

print(str.index(“元素”)) —— 查找通过元素查找索引,查找不到时就报错
```
推荐使用find，毕竟报错看着很难受。
```
isdigit() —— 判断字符串中的内容是否全是阿拉伯数字
isdecimal() —— 判断字符串中的内容是不是十进制数
isalnum() —— 判断字符串中的内容是不是数字，字母，中文
isalpha() —— 判断字符串中的内容是不是字母，中文

isascii() —— 判断字符串中是不是字母数字(3.7以上解释器中存在)

msg = "wuhuaguo"

print(msg.isdigit())      # 判断字符串中的内容是不是全都是数字(阿拉伯数字)False

print(msg.isdecimal())    # 判断是不是十进制数False

print(msg.isalnum())      # 判断是不是数字,字母,中文Ture

print(msg.isalpha())      # 判断是不是字母,中文Ture

print(msg.isascii())      # 判断是不是字母数字Ture

len() —— 查看数据类型中共有多少个元素

msg = "原谅我这一生不羁放纵爱自由"

print(len(msg)) # 公用的方法: len ，返回的是数字类型

4，list

什么是列表

列表，list，数据类型之一
储存da大量的，不同类型的数据
有序，可变，不可哈希
列表的定义：lis = []

列表的索引

列表和字符串一样也拥有索引，但是列表可以修改:

lst = ['张三','李四','赵五','陈六']

print(lst[0])  # 列表中第一个元素

print(lst[1])  # 列表中第二个元素

print(lst[2])  # 列表中第三个元素

列表的切片&步长

切片的用法和步长和字符串一样。顾头不顾尾。

lst = ["章", "菲", "绣", "花", "鲁迅"]

print(lst[0:3])     # ['章', '菲', '绣']

print(lst[:3])      # ['章', '菲', '绣']

print(lst[1::2])    # ['菲', '花'] 也有步长

print(lst[2::-1])   # ['绣', '菲', '章'] 也可以倒着取

print(lst[-1:-3:-2])    # 倒着带步长

列表的增

注意：list和str是不一样的. lst可以发生改变. 所以直接就在原来的对象上进行了操作

追加模式

append() —— 追加，在列表的末尾进行添加

lst = ["章", "菲", "绣", "花", "鲁迅"]

print(lst)  # ["章", "菲", "绣", "花", "鲁迅"]

lst.append("吃鸡")

print(lst) # ["章", "菲", "绣", "花", "鲁迅","吃鸡"]

insert(索引，插入内容) —— 插入

lst = ["章", "菲", "绣", "花", "鲁迅"]

lst.insert(1, "许褚")    # 在1的位置插入许褚. 原来的元素向后移动一位

print(lst) # ["章", "许褚","菲", "绣", "花", "鲁迅"]

extend([“safas”,“1234”]) —— 迭代添加，可以添加列表

# 迭代添加

lst = ["金志文", "张一山", "苦海无涯"]

lst.extend(["麻花藤", "麻花不疼"])

print(lst) #　["金志文", "张一山", "苦海无涯"，"麻花藤", "麻花不疼"]

列表的删

pop —— 删除，默认删除最后一个，可以用索引删除

pop有返回值，是被删除的内容。

lst = ["章", "菲", "绣", "花", "鲁迅"]

print(repr(lst.pop(2)))    # repr()查看当前数据的原生态

print(lst)  #["章", "菲", "花", "鲁迅"]

remove —— 通过元素名称删除
clear() —— 清空，留下的是空列表

lst = ["章", "菲", "绣", "花", "鲁迅"]

print(lst)  # ["章", "菲", "绣", "花", "鲁迅"]

lst.clear()

print(lst) # [s]

del list —— 通过索引，切片，步长删除

lst = ["章", "菲", "绣", "花", "鲁迅"]

del lst[3] #  ["章", "菲", "绣", "鲁迅"]

del lst[1:4]# ["章","鲁迅"]

del lst[1::2] # ['章', '绣', '鲁迅']

列表的改

通过索引修改

lst = ["章", "菲", "绣", "花", "鲁迅"]

lst[1] = "小野猪"

print(lst) # ["章", "小野猪", "绣", "花", "鲁迅"]

通过切片进行修改，默认步长为1，修改的内容必须是可迭代的对象，修改的内容可多可少

lst = ["章", "菲", "绣", "花", "鲁迅"]

lst[1:3] = "小野猪" # 默认步长为1

print(lst) # ['章', '小', '野', '猪', '花', '鲁迅']

lst[1:5:2] = "小芳","青青草原" # 步长不为1的时候，必须一一对应

print(lst) #　['章', '小芳', '绣', '青青草原', '鲁迅']

列表的查

index(“元素”) —— 通过元素查找索引
sort() —— 排序，默认是升序
sort(reverse=True) —— 降序，将升序反转

reverse() —— 将源数据进行反转

lst = [1,23,4,5,7,8,9]

lst.reverse()

print(lst)               # 将源数据进行反转

lst1 = lst[::-1]

print(lst)

print(lst1)              # 不修改源数据进行反转

for循环（遍历查询）

lst = ["章", "菲", "绣", "花", "鲁迅"]

for i in lst:

    print(i)

索引

列表的嵌套

一层一层的查找，[…]视为一个元素

lst1 = ["国际章", "阿娇", ['汪峰', "国际章", "小苹果", "小姨"],

["蔡徐坤", ["篮球", "姚明", "林书豪"], ["唱", "邓丽君", "蔡国庆", "腾格尔"],

["跳", "蔡依林", "罗志祥", "赵四", "社会摇"],

["cnb", "alex", "rimo"]]]

print(lst[-3][-1]) # 腾格尔

5，tuple

python数据类型之一。tuple：有序，不可变；只支持查询，不支持增删改。

元组中只有一个元素时：(1,)这才是一个完整的元组

（元组就是一个不可变的列表）

统计 —— count()：统计某个元素出现的次数

tu = (1,2,3,4,5,1,2,1)

print(tu.count(1)) # 3   统计元素在元组中出现的次数

获取索引 —— index()：通过元素查询索引

tu = (1,2,3,4,5,1,2,1)

print(tu.index(2)) #  1　通过元素查询索引

用途：就是将一些非常重要的不可让人改动的数据放在元祖中，只供查看。

元组的嵌套

tu = (1,2,3,4,(5,6,7,8,("alex","wusir",[1,23,4])))

print(tu[4][4][0]) #　alex

6，dict

python的数据结构之一
字典 —— dict
定义：dic = ｛“键”:“值”｝
**作用：**存储数据，大量，将数据和数据起到关联作用
字典是可变的数据类型，无序的

所有的操作都通过键

# 键:必须是不可变的数据类型(可哈希),且唯一   不可哈希就是可变数据类型

# 值:任意

dic = {"10":"苹果手机", #   键  值  对

       "11":"苹果手机",

       "15”:"小米手机",

       "15":"华为手机",

       (1,):"oppo手机",

       }

字典的增：

暴力添加，字典名[键] = 值，有则改，无则添加

dic = {'a': '上天', 'b': ['入地', '通幽'], 'c': '吃饭', 'd': '救苦救难'}

dic["二狗"] = "我的太阳" # 添加的是一个键值对

dic["腾格尔"] = ["来自草原的沙尘暴","音乐界的泥石流"]

# 新的键如果在字典中没有，那会添加到最后字典的后面；

# 如果有，那将新值替换旧值

有则不添加，无则添加

dict.setdefaullt(键，值)

dic = {'a': '上天', 'b': ['入地', '通幽'], 'c': '吃饭', 'd': '救苦救难'}

dic.setdefault("b",["沿着","江山","起起","伏"]) # 键存在，所以不添加

dic.setdefault("武器",["刀","枪","棍","棒","斧"])# 键为新，在最后一个键值对后面添加

# setdefault 添加分为2步：

# 1，先查看键是否在字典

# 2，不存在的时候进行添加

字典的删除：

pop(键) —— 通过键删除，具有返回值

dic = {"1":"上树","2":"遛狗","3":"开黑","4":"打团"}

dic.pop("1") # 删除了  "1":"上树"  这个键值对

clear() —— 清空

dic = {"1":"上树","2":"遛狗","3":"开黑","4":"打团"}

dic.clear() # 清空该字典，保留空字典

del —— 删除

del dict —— 删除的是容器

del dict[“键”] —— 通过键删除

dic = {"1":"上树","2":"遛狗","3":"开黑","4":"打团"}

del dic # 删除的是整个字典

del dic["3"] # 只删除 "3":"开黑"  这个键值对

popitem() —— 随机删除，python3.6版删除最后一个键值对

popitem返回的是被删除的键值对

dic = {}

dic.fromkeys("abc",[])

print(dic)

# {}

print(dic.fromkeys("abc",[]))

# 批量创建键值对 {"a":[],"b":[],"c":[]}

dic = dic.fromkeys("abc",[]) # 给批量这个赋值给dic

print(dic)

# {'a': [], 'b': [], 'c': []}

dic["b"] = 11

dic["a"].append(10)

print(dic)

# {'a': [10], 'b': 11, 'c': [10]}

字典的改

字典名[键] = 值

# 和字典的暴力添加一样

dic = {"1":"上树","2":"遛狗","3":"开黑","4":"打团"}

dic["2"] = "星宿老仙，法力无边" # 直接定位键，修改值

字典名.update(新字典)——在最后一个键值对后面，迭代添加

dic = {"1":"上树","2":"遛狗","3":"开黑","4":"打团"}

dic1 = {"天山派":"星宿老仙，法力无边","少林":"龙抓手"}

dic.update(dic1)

print(dic) #{'1': '上树', '2': '遛狗', '3': '开黑', '4': '打团', '天山派': '星宿老仙，法力无边', '少林': '龙抓手'}

dic1.update(dic)

print(dic1)#{'天山派': '星宿老仙，法力无边', '少林': '龙抓手', '1': '上树', '2': '遛狗', '3': '开黑', '4': '打团'}

字典的查

字典名.get(键,找不到的换回None)

dic = {"1":"上树","2":"遛狗","3":"开黑","4":"打团"}

print(dic.get("5")) # 返回 None

print(dic.get("5","找不到啊")) # 返回 找不到啊

print(dic.get("2")) # 返回 遛狗

字典名.setdefault(键)

dic = {"1":"上树","2":"遛狗","3":"开黑","4":"打团"}

print(dic.setdefault("3")) # 返回开黑

print(dic.setdefault("77")) # 返回 None

print(dic["4"]) # 也可直接查找，没有就是报错

- 字典名.keys() ——所有的键，获取到的是一个高仿列表
- 字典名.values() —— 所有的值，获取到的是一个高仿列表
- items() —— 键值
  - 注意：高仿列表支持迭代，不支持索引
```
dic = {"1":"上树","2":"遛狗","3":"开黑","4":"打团"}

print(dic.keys()) # 所有的键，获取到的是一个高仿列表

print(dic.valuse()) # 所有的值，获取到的是一个高仿列表
```

for循环，返回的是字典的键

dic = {"1":"上树","2":"遛狗","3":"开黑","4":"打团"}

for i in dic:

    print(i) # 循环出的是字典的键

字典的嵌套

dic = {11:{1:{"秦":"嬴政","秦二世","李斯","商鞅","章邯","蒙恬"},

                2:{"汉":"刘邦","韩信","卫青","霍去病"}

                3:{"三国":"魏","蜀","吴"}},

       22:{1:{"歌唱家":{"刘欢":["我和你","弯弯的月亮"]}},

            2:{"邓紫棋":["泡沫","喜欢你","天堂","光年之外"]},

            3:{"腾格尔":["隐形的翅膀","卡路里","日不落"]}},

       33:{1:{"蔡徐坤":{"唱":["鸡你太美"],"跳":["钢管舞"],"rap":["大碗面"],"篮球":("NBA形象大使")}},

            2:{"JJ":{"行走的CD":["江南","曹操","背对背拥抱","小酒窝","不潮不花钱"]}},

            3:{"Jay":{"周董":["菊花台","双节棍","霍元甲"]}}},

       44:{1:{"韦小宝":{"双儿":"刺客","建宁":{"公主":{"吴三桂":"熊"}},"龙儿":{"教主老婆":"教主"}}}}

      }

print(dic[201][1]["韦小宝"]["建宁"]["公主"]["吴三桂"])# 熊

print(dic[103][1]["蔡徐坤"]["跳"][0])# 钢管舞

print(dic[102][2]["邓紫棋"][1]) # 黑风雷

7，set

集合：set
Python 的基础数据类型之一
定义方式：s = {1,2,3.4,5,6,7,8,9}
空集合：s = set()
天然去重
- 删的重复的是后面的，先读取的不删除
- 元素要求是不可变的并且还是唯一的,我们就利用它是唯一来做去重
- 会自动排序输出的集合，从左至右，由小到大
无序,可变的数据类型

frozenset来保存数据

s = frozenset(["赵本六", "刘大脑袋", "谢广坤", "老四"])

dic = {s:'123'} # 可以正常使使用了

print(dic)

集合的增

集合名.add(“元素”)
集合名.update(“asdaf”)，迭代添加,而且是随机进添去的

print(set(“xuyu”)) ，只能添加到空集合

s = set()

s.add("alex") # 直接添加

print(s) # {'alex'}

s.update("wusir")  # 迭代添加

print(s) # {'s', 'r', 'alex', 'i', 'u', 'w'}

print(set("xuyu")) # {'y', 'u', 'x'}

集合的删

集合名.remove(元素)

s = {1,2,3,4,5,6,7,8,9,0}

print(s.remove(3))# 通过元素删除

print(s.clear())# 留下的是空集合

print(s.pop())#随机删除，默认应该是删除所有元素中最小的

集合名.clear()
集合名.pop()

集合的改

删了重新添加

集合的查

for循环

# set是一个可迭代对象. 所以可以进for循环

for el in s:

 print(el)

s1 = {"刘能", "赵四", "谢广坤"}

s2 = {"刘科长", "王大拿", "谢广坤"}

# 交集

# 两个集合中的共有元素

print(s1 & s2) # {'谢广坤'}

print(s1.intersection(s2)) # {'谢广坤'}

# 并集

print(s1 | s2) # {'刘科长', '刘能', '王大拿', '谢广坤', '赵四'}

print(s1.union(s2)) # {'刘科长', '刘能', '王大拿', '谢广坤', '赵四'}

# 差集

print(s1 - s2) # {'刘能', '赵四'} 得到第1个中单独存在的

print(s1.difference(s2)) # {'刘能', '赵四'}

# 反交集

print(s1 ^ s2) # 两个集合中单独存在的数据 {'刘科长', '王大拿', '赵四', '刘能'}

print(s1.symmetric_difference(s2)) # {'刘科长', '王大拿', '赵四', '刘能'}

s1 = {"刘能", "赵四"}

s2 = {"刘能", "赵四", "皮长山"}

# 子集

print(s1 < s2) # set1是set2的子集吗? True

print(s1.issubset(s2))

# 超集（父集）

print(s1 > s2) # set1是set2的超集吗? False

print(s1.issuperset(s2))

三，基础数据类型总结

基础数据类型总结：可变,不可变,有序,无序
- 可变：
  - list
  - dict
  - set
- 不可变：
  - int
  - str
  - tuple
  - bool
- 有序，可索引：
  - str
  - list
  - tuple
- 无序，不可索引：
  - set
  - dict
数据类型转换

int <——> str

s = str(int)，没有条件

i = int(str)，转换的字符串必须是数字

int <——> bool

非0就是True，0是False

转换数字：F = 0，T = 1

str <——> bool

Fasle = “” ， True = " "

str = “False” ，str = “True”

list <——> tuble

list = list(tuple)

tuple = tuple(list)

list <——> set

list = list(set)

set = set(list)

tuple <——> set

tuple = tuple(set)

set = set(tuple)

以下非常重要：

list ——> str
```
lst = ["1","2","3"]

print("".join(lst))
```
str ——> list
```
s = "alex wusir 太白"

print(s.split())
```