python基础篇_002_基础数据类型 Python基础数据类型

# int 用于计算
num = 3
# int 与其他数据类型转换
int_to_str = str(num)  # 数字加引号
print(int_to_str)
int_to_bool = bool(num)  # 非0 为True 否则为False
print(int_to_bool)

# bool True False 用于判断真假
b = True
# bool于其他类型之间转换
bool_to_int = int(b)  # True 1 False 0
print(bool_to_int) 
bool_to_str = str(b)  #　True False 加引号
print(bool_to_str)

"""字符串索引
下标从0开始，最后一位为-1
"""
name = "zhangsan"
print(name[0])  # 取第一个
print(name[-1])  # 取最后一个

"""字符串切片
获取字符串中的一段字符
原则:顾头不顾尾
"""
name = "zhangsan"
print(name[0:5])  # zhang
print(name[:5])  # zhang 为0时可省略
print(name[5:])  # san取到最后
"""步长"""
print(name[:5:2])  # zag
print(name[:-4:-1]) # nas

"""1.首字母大写"""
name = "zhangsan is my Name"
print(name.capitalize())  # Zhangsan is my name   后面的大写也会改为小写
"""2.特殊字符分隔，首字母大写"""
print(name.title())  # Zhangsan Is My Name
name = "dsa68fud dnsa%asdo*mmfd"
print(name.title())  # Dsa68Fud Dnsa%Asdo*Mmfd  特殊字符+数字+空格等
"""3.全部大写/小写"""
name = "zhangsan is my Name"
print(name.upper())
print(name.lower())
"""4.判断字符串开头或者结尾"""
name = "zhangsan"
print(name.startswith('z'))
print(name.startswith("zhan"))
print(name.endswith("n"))
print(name.endswith("san"))
"""5.字符或者切片出现次数"""
name = "zhangsan"
print(name.count('a'))
print(name.count("an"))  # 如果没有返回0
"""6.字符串分割"""
name = "zhangsan is my Name"
print(name.split())  # 默认分割符为空格，返回一个列表
print(name.split('a'))  # 指定分割符分割
"""7.首尾空格去除"""
name = "  zhangsan is my Name  "
print(name.strip())  # 首尾空格
print(name.lstrip())  # 左边空格
print(name.rstrip())  # 右边空格
name = "**zhangsan is my Name**"
print(name.strip("*"))  # 首尾*
"""8.format三种形式"""
info = "my name is {},my age is {},my hobby is{},my name is {}!".format('zhangsan', 20, 'study', 'zhangan')
print(info)
info = "my name is {0},my age is {1},my hobby is{2},my name is {0}!".format('zhangsan', 20, 'study')
print(info)
info = "my name is {name},my age is {age},my hobby is{hobby},my name is {name}!".format(name='zhangsan', hobby='study',
                                                                                        age=20)
print(info)
"""9.替换"""
name = "zhangsan"
print(name.replace('a', 'b'))  # zhbngsbn
print(name.replace('a', 'b', 1))  # zhbngsan
"""10.is相关"""
name='abcd123'
print(name.isalnum())  #字符串由字母或数字组成
print(name.isalpha())  #字符串只由字母组成
print(name.isdigit())  #字符串只由数字组成

"""列表的索引"""
li = [1, 2, 'a', 'b']
print(li[0])
print(li[-1])
# 类似于字符串

"""列表的切片"""
li = [1, 2, 'a', 'b']
print(li[0:2])
# 类似于字符串，得到的是新列表

# 　append 在列表最后添加
li = [1, 2, 'a', 'b']
li.append('c')  # [1, 2, 'a', 'b', 'c']
print(li)
# insert 指定索引位置添加
li = [1, 2, 'a', 'b']
li.insert(1, 'insert')
print(li)  # [1, 'insert', 2, 'a', 'b']

# 迭代追加
li = [1, 2, 'a', 'b']
li.extend("cdef")
print(li)  # [1, 2, 'a', 'b', 'c', 'd', 'e', 'f']
li = [1, 2, 'a', 'b']
li.extend([3, 4, 5])
print(li)  # [1, 2, 'a', 'b', 3, 4, 5]

# pop 指定索引位置删除
li = [1, 2, 'a', 'b']
li.pop(0)  #
print(li)  # [2, 'a', 'b']
print(li.pop(0))  # 返回被删除元素
li.pop()
print(li)  # ['a'] 默认删除最后一个元素

# remove  删除指定元素
li = [1, 2, 'a', 'b']
li.remove('a')
print(li)  # [1, 2, 'b']

# clear 清空列表
li = [1, 2, 'a', 'b']
li.clear()
print(li)

# del 删除列表
li = [1, 2, 'a', 'b']
del li
# print(li)  报错
# 删除指定索引元素
li = [1, 2, 'a', 'b']
del li[1]
print(li)  # [1, 'a', 'b']
# 删除指定切片元素
li = [1, 2, 'a', 'b']
del li[0:2] 
print(li)  # ['a', 'b']
# 删除指定切片+步长元素
li = [1, 2, 'a', 'b']
del li[0:3:2]
print(li)  # [2, 'b']

# 根据索引赋值
li = [1, 'a', 'b']
li[0] = 'v'
print(li)

# 根据切片赋值
li = [1, 'a', 'b']
li[0:2] = 'dasf'
print(li)  # ['d', 'a', 's', 'f', 'b']

# 根据切片+步长赋值   一一对应
li = [1, 'a', 'b']
li[::2] = '对应'
print(li)  # ['对', 'a', '应']

li = [1, 2, 'a', 'b']
for i in li:
    print(i)

i = 0
while i < len(li):
    print(li[i])
    i += 1

li = [1, 2, 'a', 'b']
# count 计算某个元素出现个数
print(li.count('a'))
# len
print(len(li))
# index
print(li.index('a'))
# sort
li = [3,2,5,1,4]
li.sort()
print(li)  # [1, 2, 3, 4, 5]
li.sort(reverse=True)
print(li)  # [5, 4, 3, 2, 1]
# reverse
li.reverse()
print(li)

# join 可以实现将列表转成字符串，实现无缝连接
# 字符串转成列表 split 
li = ['1', '2', 'a', 'b']
print('_'.join(li))  # 1_2_a_b

# 列表嵌套： 列表中包含列表
li = [1, 2, [3, 4, 5], 6, 7, 8]
print(li[2]) # [3,4,5]
print(li[2][0]) # 3

tu = (1, 2, 3, [4, 5, 6])
# 通过索引获取元祖中的元素
print(tu[0])
# 通过切片获取元祖中的元素
print(tu[0:3])  # (1, 2, 3)

# 直接从属于元组的元素不能更改，所以元组只能查看。
tu = (1, 2, 3, [4, 'a', 'b'], 'z')
for i in tu:
    print(i)

# 直接从属于元素元素不能更改，元祖中元素中的元素可能可以修改
tu = (1, 2, 3, [4, 'a', 'b'], 'z')
tu[3][2] = 'c'
print(tu)  # (1, 2, 3, [4, 'a', 'c'], 'z')

# count
print(tu.count('a'))
# len
print(len(tu))

# 数据类型分类
 不可变数据类型:int str bool tuple 可哈希
 可变数据类型:list dict set 不可哈希

字典： 由键值对组成
key:可哈希，不可变数据类型，且要唯一，相同的key，后面值会覆盖
value:任意

dict1 = {1: 'a', 'b': 'c', 'b': 'm'}
print(dict1)  # {1: 'a', 'b': 'm'}

# 通过key添加
dict1 = {1: 'a', 'b': 'c'}
dict1['b'] = 'm'  # 键值存在，则直接覆盖
print(dict1)
dict1['c'] = 'd'  # 键值不存在，则直接追加
print(dict1)  # {1: 'a', 'b': 'm', 'c': 'd'}

# setdefault添加
dict1 = {1: 'a', 'b': 'c'}  # {1: 'a', 'b': 'c', 'c': None}
dict1.setdefault('c')  # 默认为None
print(dict1)
dict1 = {1: 'a', 'b': 'c'}  # {1: 'a', 'b': 'c', 'c': 'ad'}
dict1.setdefault('c', 'ad')  # 没有此键，则添加，有此键，则不变
print(dict1)
dict1 = {1: 'a', 'b': 'c'}
dict1.setdefault('b', 'a')  # 没有此键，则添加，有此键，则不变
print(dict1)  # {1: 'a', 'b': 'c'}

# 通过key删除
dict1 = {1: 'a', 'b': 'c'}
dict1.pop('b')  # 有则删除，没有则报错,有返回值
print(dict1)  # {1: 'a'}

# pop加默认参数
dict1 = {1: 'a', 'b': 'c'}
dict1.pop('c', None)
print(dict1)    # 没有不报错

# popitem 随机删除
dict1 = {1: 'a', 'b': 'c'}
dict1.popitem()  # 随机删除一个
print(dict1)

# clear 清空
dict1 = {1: 'a', 'b': 'c'}
dict1.clear()
print(dict1)

# del 删除
dict1 = {1: 'a', 'b': 'c'}
del dict1['b']
print(dict1)

del dict1

# 通过key修改
dict1 = {1: 'a', 'b': 'c'}
dict1['b'] = 'f'
print(dict1)

# update
dict1 = {1: 'a', 'b': 'c'}
dict1.update(b='a1', g='g1')
print(dict1)  # {1: 'a', 'b': 'a1', 'g': 'g1'}  # 有则修改，无则添加

dict1 = {1: 'a1', 'b': 'c1'}
dict2 = {1: 'a', 'z': 'c2'}

dict1.update(dict2)
print(dict1)  # {1: 'a', 'z': 'c2', 'b': 'c1'}  # 有则修改，无则添加
print(dict2)  # {1: 'a', 'z': 'c2'}

# 通过key查
dict1 = {1: 'a', 'b': 'f'}
print(dict1['b'])  # 有则打印，无则报错

# get
dict1 = {1: 'a', 'b': 'f'}
print(dict1.get('c'))  # None
print(dict1.get('c', '没有时，默认值'))

# keys
dict1 = {1: 'a', 'b': 'f'}
print(dict1.keys())  # dict_keys([1, 'b'])
# values
dict1 = {1: 'a', 'b': 'f'}
print(dict1.values())  # dict_values(['a', 'f'])

# items
dict1 = {1: 'a', 'b': 'f'}
print(dict1.items())  # ict_items([(1, 'a'), ('b', 'f')])

a, b = 1, 2
print('a=' + str(a), 'b=' + str(b))  # a=1 b=2

a, b = (1, 2)
print('a=' + str(a), 'b=' + str(b))  # a=1 b=2

a, b = [1, 2]
print('a=' + str(a), 'b=' + str(b))  # a=1 b=2

a, b = {'a': 1, 'b': 2}
print(a, b)  # a b     拆包

dict1 = {'a': 1, 'b': 2, 'c': 3}
for k, v in dict1.items():
    print('key=' + k)
    print('value=' + str(v))
# key=a
# value=1
# key=c
# value=3
# key=b
# value=2

dict1 = {
    'name': '张三',
    'age': 21,
    'friends': [{'name': '李四', 'age': 22}],
    'hobby': {'hobby_1': '足球', 'hobby_2': '篮球', 'hobby_3': '跑步'}
}

# 获取张三
print(dict1['name'])

# 获取李四
print(dict1['friends'][0]['name'])

# 获取跑步
print(dict1['hobby']['hobby_3'])

set1 = {1, 2, 3, 'a'}  # set集合中不可重复
print(set1)  # {1, 2, 3, 'a'}

set1 = {1, 2, 3, 'a'}
set1.update('v')
print(set1)  # {1, 2, 3, 'v', 'a'}  # 没有则添加

set1.update('a')
print(set1)  # {1, 2, 3, 'v', 'a'}  # 有则不变

# 随机删除一个元素
set1 = {1, 2, 3, 'a'}
set1.pop()  
print(set1)

# 删除指定元素
set1 = {1, 2, 3, 'a'}
set1.remove('a')
print(set1)

# 清空
set1.clear()

# 删除
del set1

# 交集
set1 = {1, 2, 3, 'a'}
set2 = {2, 3, 'v'}
print(set1 & set2)  # {2, 3}
print(set1.intersection(set2))
# 并集
set1 = {1, 2, 3, 'a'}
set2 = {2, 3, 'v'}
print(set1 | set2)  # {1, 2, 3, 'a', 'v'}
print(set1.union(set2))
# 差集
set1 = {1, 2, 3, 'a'}
set2 = {2, 3, 'v'}
print(set1 - set2)  # {1, 'a'}
print(set1.difference(set2))

for i in range(1, 10):
    print(i)