Python全栈开发day2-数据类型详解

一、数字 Number

Python3 支持 int、float、bool、complex（复数）。

1. int、float、complex

python3 中所有的整型都是 int 类型，不再有长整型的概念。

a = 4
print(type(a))  # 内置type()函数可以用来查询变量类型
print(isinstance(a, int))  # isinstance()函数用来判断变量类型
print(a.bit_length())  # 转换成二进制位至少需要几位  4 -- 100

# type 和 isinstance 的区别：isinstance认为子类是一种父类型，type认为子类不是一种父类型
class A:
    pass
class B(A):
    pass

print(isinstance(A(), A))   # True
print(isinstance(B(), A))   # True
print(type(A())==A)         # True
print(type(B())==A)         # False

a = 12-36j
print(type(a))
print(a.real)   # 返回实数部分
print(a.imag)   # 返回虚数部分

2. bool

Python3 中把 True 和False 定义为关键字，值为1 和 0，可以和数字进行运算，所以暂时咱们先把它归为数字类型。

a = True
print(a)

二、字符串 String

字符串在内存中一旦创建则不可修改，若修改则会重新创建一个字符串。

a = "  hello World   "
print(type(a))
print(len(a))       # 获取字符串长度
print(a[3])
print(a[3:7])       # 字符串切片，获取子串，左闭右开
print(a.split(" "))         # 以 " "分割字符串，并返回一个列表
print(a.strip())         # 去除左右空白，可指定去除字符  a.lstrip(" ")  a.rstrip(" ")
print("_".join(a))          # 将字符串中的每个元素按指定分隔符进行拼接
print(a.find("or"))         # 查找子串“he”出现的位置，未找到返回 -1
print(a.count("o", 0, 8))         # 计算子字符串出现的次数，可以设置查找的起始位置
print(a.replace("o", "cccc", 1))   # 替换字符串，可指定替换次数，1表示只替换第一个
print(r"dfdfdf\n")      # 加上r表示将字符串原样输出

for i in a:
    print(i)

print(a.capitalize())       # 首字母大写
print(a.casefold())         # 转小写（包括一些特殊的定义关系）
print(a.islower())
print(a.lower())            # 将字符串中大写转为小写
print(a.isupper())
print(a.upper())            # 将字符串中小写转为大写
print(a.center(20, "-"))    # 设置显示宽度，字符串居中，空白位用 - 代替
print(a.endswith("a"))      # 字符串是否以‘a’结尾
print(a.startswith("a"))    # 字符串是否以‘a’开头
print(a.index("or"))        # 查找子串“he”出现的位置，找不到会报错，请使用find
print(a.isalnum())          # 判断字符串中是否只存在数字和字母
print(a.isalpha())          # 判断字符串中是否只存在字母和汉字
b = "123①"
print(b.isdecimal())        # 判断字符串是否是数字
print(b.isdigit())          # 判断字符串是否是数字，包括①
print(a.ljust(20, "*"))     # 输出长度20，左侧填充 *
print(a.rjust(20, "*"))
# 使用 \t 分割字符串，每个子串占位 20 ，可用来以表格的样式显示数据
b = "username\tpassword\temail\nzhangsan\t123456\[email protected]\nlisi\tadmin\[email protected]"
print(b.expandtabs(20))

三、列表List

列表使用方括号括起来，逗号分隔，可迭代。列表中的元素可以是任意类型

li = [123, "hello", True, 87, "ear", 123.32, "哈哈", [234, "fdf"]]
print(li[0])
print(li[2:4])

# list可以通过索引、切片的方式进行删除、修改等操作
li[0] = 100         # 修改一
li[0:2] = [34, 54]   # 修改二
del li[0]   # 删除
del li[0:2]   # 删除
print(li)

li.insert(1, "热")     # 在index=1的位置插入数据
print(li)
print(li.index("哈哈"))  # 获取当前值的索引位置，找到第一个就停止
li2 = li.copy()         # 浅拷贝
print(li2)
print(li.count(87))     # 计算元素出现的次数
li.append("地方")        # 追加，把传入对象当做一个值添加到列表中
# li.append(["湖南", "长沙臭豆腐"])
print(li)
li.extend(["湖南", "长沙臭豆腐"])  # 把传入的可迭代对象的每一个值循环取出并添加到列表中
print(li)
print(li.pop(2))   # 删除index=2的值并返回被删除的值，默认删除最后一个
print(li)
li.remove("哈哈")  # 删除指定值，删除第一个后则停止
print(li)
li.reverse()       # 列表反转
print(li)
li = [123, 45, 4, 123, 454, 656, 0]
li.sort(reverse=True)          # 列表排序，默认从小到大，reverser=True表示从大到小
print(li)

print(len(li))  # 列表长度
print(max(li))  # 列表最大值
print(min(li))  # 列表最小值

li.clear()                  # 清空

# enumerate 为一个可迭代对象添加序号，默认编号从0开始，可以之定义编号
li = ["苹果", "香蕉", '梨', '葡萄']
for k, i in enumerate(li, 1):
    print(k, i)

n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n2 = n1.copy()          # 浅拷贝
n3 = copy.deepcopy(n1)  # 深拷贝
n1["k3"][0] = "admin"
print(n2)
print(n3)

四、元组 Tuple

元组由括号括起来，逗号分隔，元组不可被修改，可迭代。写元组时最好在最后增加一个，方便和函数进行区分。

tu = ()      # 创建空元组
del tu       # 删除元组
v1 = (12,)   # 创建含有一个元素的元组
v = (123, "hello", True, 87, "ear", 123.32, "哈哈", [234, "fdf"],)
print(v[2:4])
print(v.count("哈哈"))    # 计算 "哈哈" 出现的次数
print(v.index("ear"))     # 查找 "ear" 出现的index

for i in v:
    print(i)

v[7].reverse()  # 元组的一级元素不可修改，但可以对元组内部的列表进行修改
print(v)

print(v + v1)   # 元组不可修改，但可以进行连接组合，生成一个新的元组

五、集合 Set

有不同的元素组成，无序、不可变（只能存放数字、字符串、元组）。

s = set()   # 创建空集合，必须用set()创建
s = {1, 2, 3, 4, 5, 6}
s.add("24")     # 增加元素
print(s.pop())  # 随机删除元素并返回删除的值
s.remove(5)     # 删除指定元素，不存在时会报错
s.discard(6)    # 删除指定元素，不存在时不做操作
print(s)
q = {2, 7, 3, 45, 75, 6}
print(s.union(q))               # 并集
print(s.intersection(q))        # 交集
print(s.difference(q))          # 差集 s-q
print(s.symmetric_difference(q))  # 交叉补集，只存在任一集合的数据
print(s.issuperset(q))          # q 是 s 的父集
print(s.issubset(q))            # q 是 s 的子集
print(s)
s.update([345454, 56])          # 添加多个值
print(s)
s1 = s.copy()   # 集合浅拷贝
s.clear()     # 清空集合

p = frozenset("Hello")  # 生成不可变集合
print(p)

六、字典 Dictionary

字典是一种可变容器模型，可以存储任意类型对象。整个字典包括在一个 { }中，每个键值对用 ：分隔，每个键值对之间用，分隔。字典的键必须唯一。

# 字典的键值必须唯一，且不可变，故可以使用数字、字符串、元组充当键值
# 若字典中同一个键出现两次，则后一个被记住
dic = {"name": "zhangsan", "age": 23, "address": "长沙"}
print(dic['name'])      # 取值
print(dic.get("age"))   # 取值
dic["name"] = "lisi"    # 修改值
del dic['address']      # 删除
dic2 = dic.copy()       # 字典浅复制
print(dic2)

dic3 = dict.fromkeys(["email", "phone", "school"], 123)  # 生成新的字典，默认值为123
print(dic3)

for key in dic:
    print(dic.get(key))

七、习题

1. 实现一个简单的整数加法计算器

# 实现一个简单的整数加法计算器
while True:
    add_sum = 0
    content = input("请输入整数加法运算(输入q退出)：")
    if content == "q":
        break
    li = content.split("+")
    for i in li:
        if i == "" or (not i.isdecimal()):
            print("表达式有误，请重新输入")
            break
        add_sum += int(i)
        if i == li[len(li)-1]:
            print("sum = ", add_sum)

2.  制作随机验证码，不区分大小写

# 用户执行程序，给用户提示需要输入的验证码，输入与显示一致时提示正确，否则重新生成验证码等待输入

import random

def check_code():
    code = ""
    for i in range(4):
        current = random.randrange(0, 4)
        if current != i:
            temp = chr(random.randint(65, 90))
        else:
            temp = random.randint(0, 9)
        code += str(temp)
    return code


while True:
    code = check_code()
    print("本次验证码为：" + code)
    input_code = input("请输入验证码：")
    if input_code.upper() == code or input_code.lower() == code:
        print("验证通过")
        break