python开发第二篇--基本数据类型

摘要：基本数据类型数字类型只能存取一个值数字是不可变类型，根据来看，不可变类型是可数字主要是用来计算的，使用方法不是很多，记住如下一种整数类型当十进制用二进制来表示的时候，最少使用的位数浮点型身高体质参数体重复数布尔值布尔值只有两种一种是一种是真

只能存取一个值

数字是不可变类型，根据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))

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

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

字符串只有一个值

字符串是有序的

不可变类型，可被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	hello"
# 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()) #字符串只由数字组成

元组适用于不变的数据

元组是有序的

元组是不可变类型(但是元组可以对嵌套的列表内的元素修改)

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))

存一个值或者多个值，值为任意类型

有序，可以按照索引取值

可变类型

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]整个列表翻转  

按照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)

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 无论多少层，都是互相独立的。