Python基础-数据类型

数据类型

Python有6大基本数据类型

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Sets（集合）
• Dictionary（字典）

# python3支持 int,float,bool,complex(复数)
# Long类型是Python2的
a = '2'
b = 1
c = 2.3
print(type(a))  # str
print(type(b))  # int
print(type(c))  # float

字符串截取

# 切片
str = 'abcde'
# 字符串截取  取左不取右
print(str[0:4]) # abcd
# 取整个
print(str[0:len(str)]) #abcde
print(str[:]) #abcde  只写一个冒号也是取整个
print(str[0:]) #abcde  只写一个0和冒号也是取整个
print(str[0:-1]) # abcd  -1代表最后一个字符下标 也就是倒数第一位
print(str[0:9:2])  # ace  双数的不取  没有数组越界
# 重复显示  * 后边是几就显示几遍
# 在转义前面加R或者r就是不转义
str = '2121\n'
str1 = R'2121\n'
print(str * 2)
print("##########")
print(str1 * 2)

String内置方法

# String类型方法
str = "abcd"
print(str.isdigit())  #False 判断字符串是否是数字
print(str.isupper())  #False 判断字符串是否是纯大写
print(str.islower())  #False 判断字符串是否是纯小写
print(str.isalpha())  #False 判断字符串是否是纯字母
print(str.isalnum())  #False 判断字符串是否是数字或者字母

# list 列表
#join 将列表转换为字符串
# 用list里面的东西依次拼接join前面的那个东西
list = ["1","2","3"]
print(''.join(list)) #123
print(str.join(list)) #1abcd2abcd3

# 分割 按b分割
print(str.split('b')) # ['a', 'cd']

# 列表  list
list = [1,2,3,4]
print(list) #[1, 2, 3, 4]
print(len(list)) # 长度 4
print(list[2]) # 打印下标是2的

list1 = [1,2,3,4,5,6,7,8,9]
# 步长
print(list1[0:len(list1):2]) # 隔一位取一个
print(list1[0:len(list1):3]) # 隔两位取一个

list的方法

list = [1,2,3,4,5,6,7,8,9]
list[0] = 0
print(list)  # 替换 [0, 2, 3, 4, 5, 6, 7, 8, 9]

list.append(10)
print(list)  # 增加 [0, 2, 3, 4, 5, 6, 7, 8, 9, 10]

list.pop()
print(list)  # 删除 [0, 2, 3, 4, 5, 6, 7, 8, 9]

list.pop(0)  # 删除指定下标的成员
list.remove(3)  # 删除指定成员
print(list)
list.clear()  #  清空
list = [] #  清空

#  index 输出指定下标  第一个位置的
result = list.index(6)
print(result) # 3

# 统计个数  计算6在这个字符串出现的次数
print(list.count(6))  

# 排序  升序
list.sort()
print(list)  #  [2, 4, 5, 6, 6, 7, 8, 9]
# 降序
list.sort(reverse = True)
print(list)  #  [9, 8, 7, 6, 6, 5, 4, 2]
#  反序
list.reverse()
print(list)  # [2, 4, 5, 6, 6, 7, 8, 9]

元组tuple

# 元组 Tuble
# 元组的元素不可以修改,也就是不支持修改增加删除list是可以修改的，元组必须写在小括号里面，元素之间用逗号隔开，元组中的元素类型也可以不相同
tuple = ()
print(type(tuple)) # <class 'tuple'> 类型是元组 就是括号里面的就是元组
print(tuple)  # ()

Tuple1 = (1,23,3,"元组")
print(Tuple1)  # (1, 23, 3, '元组')
print(type(Tuple1)) # <class 'tuple'>
print(Tuple1[2]) # 3

# 元组的两个方法
tuple1 = (1,2,3,4)
print(tuple1.count(2))  # 1  统计2出现的次数
print(tuple1.index(2,0,len(tuple1)))  # 统计2第一次出现的位置的下标

# 但是元组里面嵌套的要是列表的话就是可以修改的
# 但是记得话还是记得不要修改  毕竟这是list里面修改的
tuple2 = [1,2,3,[1,2,3]]
tuple2[3][1] = 22
print(tuple2)  #  [1, 2, 3, [1, 22, 3]]

set集合

# Set集合  无序不可重复  就是可以去重
# 1. 定义一个空集合
set = set()
print(type(set))  # <class 'set'>
print(set)   # set()

# 定义有数据的集合
set1 = {1,2,3,4,5,6}
print(type(set1))  # <class 'set'>
print(set1)  # {1, 2, 3, 4, 5, 6}

# 定义一样的数据可以去重 
set2 = {1,2,3,4,5,6,1,2}
print(set2)  # {1, 2, 3, 4, 5, 6}

# 无序 不可以指定下标
print(set[1]) # 会报错

# 并集
set1 = {1,2,3,4,5,6}
set2 = {1,2,3,4,5,6,11,22}
print(set1 | set2) # 并集  {1, 2, 3, 4, 5, 6, 11, 22}
print(set2 - set1) # 差集  {11, 22}
print(set1 - set2) # 差集  不够减得情况下就会出现空集合 就是set()
print(set1 & set2) # 交集  {1, 2, 3, 4, 5, 6}
print(set1 ^ set2) # 亦或  就是交集的反方向  {11, 22}

# set的pop() 方法是随机删除的 因为他是无序的

有很多方法

字典

dict = {}
print(type(dict))  #  <class 'dict'>
字典就是键值对 key value的
dict1 = {"name":"gy","age":18}
print(dict1) # {'name': 'gy', 'age': 18}

修改
dict1["name"] = "gy1"
print(dict1) # {'name': 'gy1', 'age': 18}

字典无序 不支持索引

拿所有的key,value
print(dict1.keys()) # dict_keys(['name', 'age'])
print(dict1.values()) # dict_values(['gy1', 18])

返回指定建名
print(dict1.get("name")) # gy1
print(dict1["name"]) # gy1

删除字典
dict1.pop("name")

清空字典
dict1.clear()
同一个字典中，键是惟一的 创建空字典是{}

数据类型转换

就是在要转换的前面加上要转换成的那个类型

# 数据类型转换
# 1. 将整型转换为float
a = 2
b = float(a)
print(a,b) # 2 2.0

# 2.将float转换为整型
c = 2.2
d = int(c)
print(c,d) # 2.2 2 会强制把小数位去掉

# 3.将数字转化为字符串 字符串就是str  没有string
c1 = 2
d1 = str(c1)
print(c1,d1) # 2 2
print(type(c1),type(d1)) # <class 'int'> <class 'str'>

print("###############")

# 计算正则的方法 eval
r = '1+2'
u = eval(r)
print(type(r),type(u)) #<class 'str'> <class 'int'>
print(r,u) # 1+2,3

# 字符串转换为list
n = 'zahngsan'
m = list(n)
print(type(n),type(m)) # <class 'str'> <class 'list'>
print(n,m) # zahngsan ['z', 'a', 'h', 'n', 'g', 's', 'a', 'n']

# 字符串转换为元组
n1 = 'lisi'
m1 = tuple(n1)
print(type(n1),type(m1)) # <class 'str'> <class 'tuple'>
print(n1,m1) # lisi ('l', 'i', 's', 'i')


# 字符串转换为集合
n11 = 'lisiii'
m11 = set(n11)
print(type(n11),type(m11)) # <class 'str'> <class 'set'>
print(n11,m11) # lisiii {'i', 'l', 's'}  结果少了是因为自动去重了