Python 基础数据类型的使用

Python 基础数据类型

一. 基础数据类型的使用

1.数字

int: num = 10  => 存放的是整型数字
float: num = 3.14  => 存放的是浮点型数字
bool: r = True  => 存放的其实就是数字0(False) | 1(True)

三者均可以直接做数值的所有运算

类型的转换
以 int("123") float(3) bool(1) 来定义变量

需求: 交互两个变量的值
交叉赋值
a, b = b, a
# 按位进行一对一赋值

数字的使用

# int 整型
# float 浮点型
# bool 布尔类型

# +验证
a = 10
b = 20
print(a + b)    # 输出结果 30

c = 3.14
d = 1.86
print(c + d)   # 输出结果 5.0

e = True
f = False
res = e + f
print(res, type(res))   # 输出结果 1 <class 'int'>
# 1 + 1 + 0 * 1
print(True + True + False * True) # 输出结果 2

# 以类型方式定义变量
num = int(10)
print(num, id(num), type(num)) 
# 输出结果 10 1375655104 <class 'int'>

# 将可以转换为整型的其他类型数字,转换为整型
# 数据类型的转换
num = int(3.14)
print(num, id(num), type(num))
# 输出结果  3 1375654992 <class 'int'>

# 将表示数值的字符串转换为数字类型
s = "88888"
num = int(s)
print(num, id(num), type(num))
# 输出结果  88888 52621600 <class 'int'>

# 了解: Python以换行作为语句的结束标志(断句)
# 如果出现一行有多条语句,之间可以用;作为结束标志
# 需求: 交互两个变量的值
a = 10; b = 20
# 结果: a = 20 | b = 10
print(a, b)    # 输出结果 10 20

# 借助第三者
# temp = a
# a = b
# b = temp
print(a, b)     # 输出结果 10 20

# 利用计算的算法
# res = a + b
# a = res - a
# b = res - b
print(a, b)     # 输出结果 10 20

# 利用交叉赋值
a, b = b, a  
print(a, b)     # 输出结果 20 10

2.字符串

"I am a \"good boy\""
r"I am a \"good boy\""
b"\xe5\x91\xb5"
+ | * | [] | [:] | in | not in
%d %f %x %s
upper() | lower() | capitalize() | split() | join()
good good study day day up  => Good Good Study Day Day Up

表示方式
字符串三种表示方式
''  ""  """""" 
多种引号之间可以形成嵌套,出现同类型引号时,可以采用转义字符处理
' "" ' | """ "" """ | " \" \" " | " '' "
原字符串: 保留所有合法的字符,原样输出 
r""
编码字符串: 以二进制形式存在,用十六进制展示给用户看
b""
encode("编码的字符串名") decode("解码的字符串名")  编码与解码应该统一  utf-8 |gbk

拼接: +
重复: *
取字符: [index]
切片: [0:-3] 从第0位(开始)截取到倒数第3位之间
判断: in: 某指定字符或字符串是否在目标字符串中出现了 | not in: in的对立面
# "ac" in "abc"   => False

全大写: upper()
全小写: lower()
首字母大写: capitalize()
拆分: split()  eg: s1.split("@") => 将s1字符串按@符号进行拆分
合并: join()  eg: "&".join(s_list) => 用&将s_list集合中的所有元素挨个拼接起来

字符串的使用

# 可以用'' | "" | """""" 来表示字符串
s1 = "你有100w人民币"
print(s1)   # 输出结果  你有100w人民币

# 需求: 你有"100w"人民币
# ① 利用引号嵌套的方式
#s2 = '你有"100w"人民币'
s2 = """你有"100w"人民币"""
print(s2)   # 输出结果  你有"100w"人民币

# ② 利用转义字符
# \n  =>  换行符
s3 = "你有\"100w\"人民币"
print(s3)    # 输出结果  你有"100w"人民币 

# 另外两种常见的字符串表示方式
# r"": 原始字符串
# 字符串中所有合法字符串都以原型显示
s4 = r"你有\"100w\"人民币"
print(s4)    # 输出结果  你有\"100w\"人民币

# b"": 编码字符串
# 编码解码 md5  utf-8 | gbk
# 进制: 二进制 十进制 十六进制

# s5 为普通字符串
s5 = "呵呵"
print(s5)    # 输出结果 呵呵
s5 = s5.encode("utf-8")  # 普通字符串可以进行编码操作
print(s5)    # 输出结果  b'\xe5\x91\xb5\xe5\x91\xb5'

# s5 为编码字符串
s5 = s5.decode("utf-8")  # 普通字符串可以进行解码操作
print(s5)   # 输出结果   呵呵

# 1011 => 8421 => 8 + 2 + 1 =>b
# ba => 10111010

s6 = b'\xe5\x91\xb5'
s6 = s6.decode('utf-8')
print(s6)     # 输出结果  呵


# + | * | [] | [:] | in | not in
# 字符串拼接
a = "hello"
b = "world "
# hello world
res = a + " " + b   # 拼接得到的是新字符串 ,原字符串数据会保留
print(res)  # 输出结果  hello world
print(a)    # 输出结果  hello

name = "Bob"
tag = 1
name = name + str(tag)
print(name)     # 输出结果 Bob1

# 字符串重复
print("*" * 30)  # 输出结果  ******************************

# 取指定索引对应的字符 []
s7 = "今天天气不好! Ai...."
print(s7[0])   # 输出结果  今
print(s7[8])   # 输出结果  A
print(s7[-1])  # 输出结果  .
print(s7[-6])  # 输出结果  A

# [:] 切片: 遵循半闭半开规则 [n, m) 从n取到m  n <= res < m
print(s7[8:])  # 从索引8开始,截取到最后   输出结果  Ai....
print(s7[:-6])  # 在开始截取到倒数第6位之前   输出结果  今天天气不好!
print(s7[4:6])  # 截取索引4,5号位字符    输出结果  不好

# 字符存在与否的判断
print("a" not in s7)  # 输出结果  True
print("A" in s7)   # 输出结果  True
 
# upper() | lower() | capitalize() | split() | join()
# 全大写
print("abc".upper())  # 输出结果  ABC
# 全小写
print("XyZ".lower())   # 输出结果  xyz
# 首字母大写
print("hello world".capitalize())  # 输出结果  Hello world
# 拆分
data = "name='Eira'@age=8@gender='男'"
res = data.split("@")
print(res)  # 输出结果  ["name='Eira'", 'age=8', "gender='男'"]
# 拼接
# & => name='Eira'&age=8&gender='男'
result = "&".join(res)
print(result)  # 输出结果 name='Eira'&age=8&gender='男'

# 需求: good good study day day up  => Good Good Study Day Day Up
source = 'good good study day day up'
# 第一步: 拆分
s_list = source.split(r' ')
# print(s_list)
# 第二步: 首字母大写
# 解压赋值
a, b, c, d, e, f = s_list
print(a, b, f)  # 输出结果  good good up
# a = str(a).capitalize()
a = a.capitalize()
print(a)   # 输出结果 Good
b = b.capitalize()
c = c.capitalize()
d = d.capitalize()
e = e.capitalize()
f = f.capitalize()
# 第三步: 合并
result = r" ".join([a, b, c, d, e, f])
print(result)       # 输出结果 Good Good Study Day Day Up

3.列表

[1, 3, 1, 2, 2, 1, 5]
[1, 3.14, "嘿嘿", True]
[[1, 2, 3], ('a', 'b', 'c'), {"name": "宙斯"}]
+ | * | [] | [:] | in | not in
append(o) | insert(i, o) | remove(o) | pop(i) | clear()
sort(reverse=True)

空列表: []
可以包含重复元素(集合中出现的成员就叫做元素): [1, 2, 1]
可以出现不同类型: [1, 3.14 True]
嵌套: [1, [2, [3]], {}]
取值: [index] index从0开头到结尾,或-1从结尾到开头
切片: [b_index:e_index]
判断: in | not in  判断元素是否在列表中

增: append("1") | insert(1, "0")
删: remove("1") | pop(1) | clear()
改: list[0] = 12345
查: list[0]

排序: 一个存放同类型,具有可比性的数据的列表
正序: list.sort()
倒序: list.sort(reverse=True)

列表操作

ls1 =[]
print(ls1, type(ls1))   # 输出结果  [] <class 'list'>

# 列表中可以出现重复数据
ls2 = [1, 3, 2, 1, 2, 1]
print(ls2)  # 输出结果 [1, 3, 2, 1, 2, 1]

# 列表中可以出现不同类型的数据
ls3 = [1, 3.14, True, (), {}]
print(ls3)  # 输出结果 [1, 3.14, True, (), {}]

# 列表通过索引取值(索引从0开始), 取值符号为[]
# res = ls3[4]
res = ls3[-1]
print(res, type(res))  # => {}代表空字典   输出结果 {} <class 'dict'>
# ()代表空元组,但只包含一个元素的元组的表示方式(元素,)
x = (1,)
print(x, type(x))   # 输出结果 (1,) <class 'tuple'>

# 切片
res = ls3[1:3]
print(res)  # 输出结果 [3.14, True]

# 判断
print("3.14" in ls3)  # 输出结果 False
print(3.14 in ls3)    # 输出结果 True

# 嵌套
ls4 = [1, [2, [3]], {}]
# 需求: 访问数值2, 3
print(ls4[1][0])     # 输出结果 2
print(ls4[1][1][0])  # 输出结果 3

# 列表的增删改查
# append(o) | insert(i, o) | remove(o) | pop(i) | clear()

ls5 = [1, 2]
print(ls5)   # 输出结果 [1, 2]
# 查
print(ls5[1])    # 输出结果 2
# 改
ls5[1] = "2"
print(ls5)    # 输出结果 [1, '2']
# 增
# 增加到末尾
ls5.append(3)
print(ls5)   # 输出结果 [1, '2', 3]
# 增加到指定位
ls5.insert(1, True)  # 将元素插入到列表的第1位
print(ls5)    # 输出结果 [1, True, '2', 3]

# 将指定元素删除
ls5.remove("2")  # 参数为True,删除了列表的首位
print(ls5)   # 输出结果 [1, True, 3]

# 通过索引删除
ls5.pop(1)
print(ls5)    # 输出结果 [1, 3]

# 清空
ls5.clear()
print(ls5)   # 输出结果 []

# 排序: 集合中存放的是可以排序的同一类型数据
ls6 = [3, 1, 4, 2, 5]
print(ls6)   # 输出结果 [3, 1, 4, 2, 5]
ls6.sort()  # 排序操作的是列表本身,列表会发生变换,所以排序不需要返回值
print(ls6)   # 输出结果 [1, 2, 3, 4, 5]

# 设置是否逆向排序
ls6.sort(reverse=True)
print(ls6)   # 输出结果 [5, 4, 3, 2, 1]

4.字典

空字典: {}
key的类型: str | int | float | bool | tuple  这些不可变类型
value的类型: 所有Python支持的类型

增删改查
dic[key]
增: 原dic中没有出现该key,就是增 dic[key] = value
删: 删除已有的key及对应的值 del dic[key]
改: 对已有的key重新赋值 dic[key] = new_value
查: 取已有key的值 dic[key]

# 空字典
dic =  {}
print(dic, type(dic))  # 输出结果  {} <class 'dict'>

# 定义字典: key-value形式键值对
dic = {"name": "Eira"}
print(dic)  # 输出结果  {'name': 'Eira'}

# key可以为哪些类型: 不可变类型 str | int | float | tuple | bool, 常用 str
# value可以为哪些类型: 所有类型
dic = {1: 1, 3.14: "1", True: {}, (): [], "a": [{1:1}]}
print(dic)  # 输出结果  {1: {}, 3.14: '1', (): [], 'a': [{1: 1}]}

# 增删改查
dic = {"name": "Eira"}
print(dic)  # 输出结果  {'name': 'Eira'}
# 增
dic["age"] = 88
print(dic)  # 输出结果  {'name': 'Eira', 'age': 88}
# 删
del dic["name"]
print(dic)  # 输出结果  {'age': 88}
# 改
dic["age"] = 90
print(dic)  # 输出结果  {'age': 90}
# 查
print(dic["age"])  # 输出结果  90