python3--基本数据类型和数据结构

数据类型：int、float、bool、complex、str、tuple、list、dict、set

• 不可变数据类型（可哈希）：int、float、bool、complex、str、tuple
• 可变数据类型（不可哈希）：list、dict、set

数据结构：tuple、list、dict、set

查看数据类型的内置函数：type(数据)

1.整型int

  内置函数：int()

  str->int，字符串只能是整数字符串，其他都会报错“ValueError”

print(type(10))     # 
# 字符串转换为数字
print(int('10'))  # 10
# 布尔值转换为数字
print(int(True))  # 1

2.浮点型float

 内置函数：float()

print(type(10.2))   # 
print(float('10.2'))  # 10.2

3.布尔型bool

  bool值有True---1，False---0 

  内置函数：bool()

  其他数据类型转为布尔型，值为False：0，0.0，''，[]，{}，()，set()，None，其他均为True

print(type(True))   # 
# 整型
print(bool(0))  # False
print(bool(10))  # True
# 浮点型
print(bool(0.0))  # False
print(bool(10.2))  # True 
# 复数
print(bool(10+2j))  # True 
# 字符串型
print(bool(''))    # False
print(bool('  '))  # True
print(bool('0'))   # True
# list
print(bool([]))    # False
# tuple
print(bool(()))    # False
# dict
print(bool({}))
print(dict == type({}))  # True
# set
print(bool(set()))    # False
print(set == type(set()))  # True
# None
print(bool(None))  # False

4.复数complex

  内置函数：complex()

print(type(10+2j))  # 
print(complex('10+2j'))  # (10+2j)
# 取复数的实部、虚部
com = 10 + 2j
print(com.real,com.imag)  # 10.0 2.0

5.字符串str

  字符串相关函数：capitalize()、upper()、lower()、swapcase()、title()、center()、len()、startwith()、endwith()、find()、    index()、strip()、lstrip()、rstrip()、count()、split()

  int->str，float->str，bool->str，complex->str，使用str()

print(type('hello word'))   # 
# 整型转字符串
print(type(str(10)))  # 
# 浮点型转字符串
print(type(str(10.2)))  # 
# 布尔值转字符串
print(type(str(True)))  # 
# 复数转字符串
print(type(str(10+2j)))  # 
# # 字符串操作
str1 = "this's My dream---"
# 字符串首字母大写
print(str1.capitalize())  # This's my dream---
# 字母全部大写
print(str1.upper())  # THIS'S MY DREAM---
# 字母全部小写
print(str1.lower())  # this's my dream---
# 大小写反转
print(str1.swapcase())  # THIS'S mY DREAM---
# 被隔开的字符串首字母大写
print(str1.title())  # This'S My Dream---
# 填充居中
print(str1.center(20, '-'))  # -this's My dream----
# 字符串长度
print(len(str1))  # 18
# 整个字符串以this开头
print(str1.startswith('this'))  # True
# 从2开始到5的字符串，以i 开头
print(str1.startswith('i', 2, 6))  # True
# 以-结尾
print(str1.endswith('-'))  # True
# 从2开始到5的字符串，以e结尾
print(str1.endswith('e', 2, 6))  # False
# 通过元素找索引
print(str1.find('s'))  # 3
print(str1.index('s'))  # 3
# 去掉前后-
print(str1.strip('-'))  # this's My dream
# 去掉前后空格、-、*
print(str1.strip(' -*'))  # this's My dream
# 去掉前面的-
print(str1.lstrip('-'))  # this's My dream---
# 去掉后面的-
print(str1.rstrip('-'))  # this's My dream
# 统计指定字符串的个数,返回int型
print(str1.count('s'))  # 2
# 以空格分隔字符串
print(str1.split())  # ["this's", 'My', 'dream---']

  字符串索引及切片

# # 字符串的索引与切片
str3 = 'I hate you'
print(str3[0])  # 取出字符串中的I
# 顾头不顾尾,取出字符串中的0-5的值
print(str3[0:6])  # I hate
# 取出字符串中倒数第二位
print(str3[-2])  # o
# 取出整个字符串
print(str3[0:])  # I hate you
print(str3[:] )  # I hate you
# 从字符串0-5(I hate)中隔一个字符取一个
print(str3[0:6:2])         # Iht
# 倒着输出整个字符串
print(str3[-1::-1])  # uoy etah I
# 从I hat倒着隔一个字符输出
print(str3[4::-2])  # thI

6.元组tuple

  元组为不可变数据类型，元组中的元素不可变，但如果包含可变数据类型的元素，那么这个元素的子元素是可以变的。

  元组中如果只有一个元素，要在这个元素后面加逗号（,），否则不是元组。

print(type((1, 2)))   # 
# 元组的相关操作
tu = ('can', 'cancel', ['women', 'man'])
'''******************查询元组中的元素**************************************'''
# 1.循环查
for i in tu:
    print(i)
# can
# cancel
# ['women', 'man']
# 2.按索引查
print(tu[2])  # ['women', 'man']
# 3.切片查
print(tu[0:2])  # ('can', 'cancel')
'''******************修改元组中可变数据类型元素**************************'''
tu[2][0] = 'girl'
print(tu)   # ('can', 'cancel', ['girl', 'man'])

  

7.列表list

  列表中的元素是有序的。列表可执行增删改查操作。

print(type([1, 2, 3]))   # 
# # 列表list
li = ['women', 'girl', 'boy']
'''***************查元素********************'''
# 1.取列表中指定位置的值
# 取列表中位置0的元素
print(li[0])  # women
# 2.切片，查列表中第0和第1个元素
# 切片会生成新的列表，占用内存
print(li[0:2])  # ['women', 'girl']
# 3.循环输出列表中的元素
for i in li:
    print(i)
for i in range(len(li)):
    print(li[i])
# 以上两种方式等价，输出结果为：
# women
# girl
# boy
'''***************增元素********************'''
# 1.append
li.append('friend')
print(li)  # ['women', 'girl', 'boy', 'friend']
# 2.insert
# 指定位置插入值
li.insert(1, 'sex')
print(li)  # ['women', 'sex', 'girl', 'boy', 'friend']
# 3.extend
# 参数必须是可迭代的，不可以是数字
li.extend('hello%jim')
print(li)   # ['women', 'sex', 'girl', 'boy', 'friend', 'h', 'e', 'l', 'l', 'o', '%', 'j', 'i', 'm']
'''***************删元素********************'''
# 1.pop，有返回值
re = li.pop(1)  # 删掉位置1的元素sex
print(re, '--', li)  # sex -- ['women', 'girl', 'boy', 'friend', 'h', 'e', 'l', 'l', 'o', '%', 'j', 'i', 'm']
# 2.remove，按元素删除
li.remove('boy')
print(li)  # ['women', 'girl', 'friend', 'h', 'e', 'l', 'l', 'o', '%', 'j', 'i', 'm']
# 3.del，切片删除
# 删除2到最后一个位置的元素
del li[2:]
print(li)  # ['women', 'girl']
# 4.clear,清空列表
# li.clear()  # 清空
# print(li)  # []
'''***************改元素********************'''
# 1.修改指定位置的元素
li[0] = 'men'
print(li)  # ['men', 'girl']
li[0] = [1, 2, 3]
print(li)  # [[1, 2, 3], 'girl']
# 2.切片改
# 修改列表中位置0的元素
li[0:1] = 'went'
print(li)  # ['w', 'e', 'n', 't', 'girl']
# 修改列表中位置0-4的元素
li[0:5] = 'cold'
print(li)  # ['c', 'o', 'l', 'd']

  列表其他相关的操作

# # 列表相关的其他操作
# 1.列表的长度
print(len(li))  # 4
# 2.列表中指定元素的个数
print(li.count('c'))  # c的个数1
# 3.查找元素在列表中的位置
print(li.index('d'))  # 3
# 4.列表排序
# 升序
li2 = [1, 7, 3, 5, 10]
li2.sort()
print(li2)  # [1, 3, 5, 7, 10]
# 降序
li3 = [1, 7, 3, 5, 10]
li3.sort(reverse=True)
print(li3)  # [10, 7, 5, 3, 1]
# 反转
li4 = [1, 7, 3, 5, 10]
li4.reverse()
print(li4)  # [10, 5, 3, 7, 1]
# 5.列表转换为字符串,join
li6 = ['hello', 'mike', 'tom']
str12 = '+++'.join(li6)
str13 = '+++'.join('love')
print(str12, str13)  # hello+++mike+++tom l+++o+++v+++e
# 6.字符串转换为列表，split
lis = str12.split('+++')
print(lis)  # ['hello', 'mike', 'tom']
# 7.列表的嵌套查询
# 按照位置输出
li5 = ['hello', 'mike', 'tom', ['12', '13', '14', '15']]
print(li5[3][1])  # 输出13
# 循环列表输出
for i in li5:
    if type(i) == list:
        for j in i:
            print(j)
    else:
        print(i)
# 8.range，数字列表
# 输出0-10之间的偶数，不包括10
for i in range(0, 10, 2):  
    print(i)
# 倒序输出0-10之间的偶数，不包括0
for i in range(10, 0, -2):  
    print(i)
# 输出一个range的值，需要转换为list，不可直接输出
print(list(range(10)))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

8.字典dict

  字典是无序的，字典的key必须是不可变数据类型(frozenset可以为字典的key)，可哈希。字典可执行增删改查操作。

print(type({'name':'tom','age':12}))  # 
dic1 = {'name': 'tom', 'weight': 189}
'''*******************************字典中增加元素****************************'''
# 1.指定新的key及value
dic1['sex'] = '女'
print(dic1)  # {'name': 'tom', 'weight': 189, 'sex': '女'}
# 2.设置一个key对应的默认值
# 原来没有key-high，则增加
dic1.setdefault('high', 170)
print(dic1)  # {'high': 170, 'name': 'tom', 'weight': 189, 'sex': '女'}
# 原来有key-high，但不覆盖原值
dic1.setdefault('high', 190)
print(dic1)  # {'high': 170, 'name': 'tom', 'weight': 189, 'sex': '女'}
'''*******************************删除字典中的值******************************'''
# 1.pop,有返回值,返回删除的value
# retu = dic1.pop('high', '没有值')
# print(retu, dic1)  # 170 {'name': 'tom', 'weight': 189, 'sex': '女'}
# 2.popitem，随机删除一个
# dic1.popitem()
# print(dic1)   # {'weight': 189, 'sex': '女'}
# 3.del，指定key删除
# del dic1['weight']
# print(dic1)  # {'name': 'tom', 'high': 170, 'sex': '女'}
# 4.del删除整个字典
# del dic1
# print(dic1)
# 5.clear清空字典
# dic1.clear()
# print(dic1)  # {}
# 6.循环列表，删除字典元素
# # 注意:不能循环字典删除字典的元素
# 删除字典中key为基数的值
lis = []
dic = {0:11, 1:22, 2:33, 3:44, 4:55}
# 循环key，获得要删除元素的key值，放入lis列表
for i in dic:
    if i % 2 != 0:
        lis.append(i)
# 循环列表删除字典中指定key的元素
for i in lis:
    del dic[i]
print(dic)  # {0: 11, 2: 33, 4: 55}
'''*******************************修改字典中的值******************************'''
# 1.指定key修改对应的值
dic1['name'] = 'xiaohua'
print(dic1)  # {'weight': 189, 'sex': '女', 'high': 170, 'name': 'xiaohua'}
# 2.update，用另一个字典修改字典的值，如原字典中已有则修改，没有则增加到原字典中
dic2 = {'name': 'abc', 'occupation': 'hfk'}
dic1.update(dic2)  # 修改dic1
print(dic1)   # {'weight': 189, 'sex': '女', 'high': 170, 'name': 'abc', 'occupation': 'hfk'}
print(dic2)   # {'name': 'abc', 'occupation': 'hfk'}
'''*************************************查询字典******************************'''
# 1.取key
print(dic1.keys())  # dict_keys(['weight', 'occupation', 'high', 'sex', 'name'])
# 下面两个for循环取key等价
for i in dic1:
    print(i)
for i in dic1.keys():
    print(i)
# weight
# occupation
# high
# sex
# name
# 2.取value
print(dic1.values())  # dict_values([189, 'hfk', 170, '女', 'abc'])
# 通过key取值
print(dic1['name'])  # xiaohua
# 使用get，避免无key值时，取值报错
print(dic1.get('names', '无此键'))  
# 3.取(key,value)
print(dic1.items())  # dict_items([('weight', 189), ('occupation', 'hfk'), ('high', 170), ('sex', '女'), ('name', 'abc')])
for k, v in dic1.items():
    print(k, v)
# weight 189
# occupation hfk
# high 170
# sex 女
# name abc

  字典其他相关操作

# 字典嵌套
# 先取出字典中key对应的value值，再根据value值对应的数据类型执行相关操作
dic3 = {
    "name": ['Jack', 'Tom'],
    "age": [20, 38]
}
dic3['name'].append("Mary")
print(dic3)  # {'name': ['Jack', 'Tom', 'Mary'], 'age': [20, 38]}

9.集合set

  集合是可变的，元素不可重复的、元素间无序的数据类型。字典的key符合集合的特性。

  集合中的元素必须是不可变的数据类型（可哈希）。

  list->set,set->list可实现列表中的元素去重。

print(type({'name', 'age'}))  # 

set1 = {'hello', 'word'}
print(set1, type(set1))  # {'word', 'hello'} 
'''*******************************增加元素************************************'''
# 1.add，整个数据增加
set1.add('you')  # {'hello', 'you', 'word'}
print(set1)
# 2.update，拆分成单字符增加
set1.update('my')  # {'hello', 'you', 'm', 'word', 'y'}
print(set1)
'''*******************************删除元素************************************'''
# 1.pop随机删除，有返回值，返回被删除了的元素
# print(set1.pop())  # word
# 2.remove按元素删除
# set1.remove("hello")
# 3.clear,清空集合
# set1.clear()  # 空集合--set()
# 4.del,删除集合
# del set1
'''*******************************查找元素************************************'''
# 循环查找，不支持索引及切片操作
for i in set1:
    print(i)
# y
# word
# m
# you
# hello

  集合相关的其他操作

## 两集合求交集、并集、反交集、差集、子集、超集
# 1.交集
set2 = {1, 2, 3, 4, 5}
set3 = {3, 4, 5, 6}
print(set2 & set3)  # {3, 4, 5}
print(set2.intersection(set3))  # {3, 4, 5}
# 2.并集
print(set2 | set3)  # {1, 2, 3, 4, 5, 6}
print(set2.union(set3))  # {1, 2, 3, 4, 5, 6}
# 3.反交集
print(set2 ^ set3)  # {1, 2, 6}
print(set2.symmetric_difference(set3))  # {1, 2, 6}
# 4.差集
print(set2 - set3)  # {1, 2}
print(set2.difference(set3))  # {1, 2}
# 5.子集
print(set2 < set3)  # set2 不是set3的子集False
print(set2.issubset(set3))  # set2 不是set3的子集False
# 6.超集
print(set3 > set2)  # set3 不是set2的超集False
print(set3.issuperset(set2))  # set3 不是set2的超集False
## 不可变集合frozenset，只能查，不能改
s = frozenset('hello')
print(s)  # {'e', 'l', 'o', 'h'}

ps:数字与str类型有小数据池的概念，即在一定的数据范围内，不同变量，赋相同值，则这些变量指向相同的内存空间，一个变量改变，另外的变量值也会同样改变，这些变量完全相同。列表、元组、集合、字典没有小数据池，不同变量指向不同的内存空间。

# 两个整型变量指向相同的内存地址
i1 = 6
i2 = 6
print(i1 is i2)  # True
# 两个列表，指向不同的内存地址
li7 = ['1', 'klo']
li8 = ['1', 'klo']
print(li7 is li8)  # False