数据类型-数字-字符串-列表-元组-集合-字典

数字类型转化

'''
1. int(x)函数，转化为整型

2. float(x)函数，转化为浮点型

3. complex(x)函数，实部为x，虚部为0

4. complex(x,y)函数，实部为x，虚部为y

5. bin(x)函数，转化为二进制

6. oct(x)函数，转化为八进制

7. hex(x)函数，转化为十六进制
'''

 

二、数学常量

1. e自然常量

2. pi圆周率

# -*- coding: utf-8 -*-

import math

# 圆周率

print(math.pi)

# 自然常量

print(math.e)

三、数学函数

'''
四、数学函数
abs(x)：绝对值，整型
round(x,[,n])：四舍五入，3.3 => 3，3.5 => 4，指定n四舍五入以后保留的小数位数
max(x1,x2,x3,...)：最大值
min(x1,x2,x3,...)：最小值
pow(x,y)：求x的y次方

import math 
math.
    ceil(x)：向上取整，1.1 => 2，1.9 => 2
    floor(x)：向下取整，1.1 => 1，1.9 => 1
    exp(x)：e的x次方
    fabs(x)：绝对值，浮点型
    log(x)：默认以自然常量e为基数的x的对数
    log10(x)：默认以10为基数的x的对数
    log(y,x)：以x为基数的y的对数
    modf(x)：分离整数部分和小数部分
    sqrt(x)：求x得平方根
'''

 

四、随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。 python包含以下常用随机数函数：

'''
import random

random.
    choice(序列)：从序列中随机挑选一个元素
    randrange([起始值,]结束值[,公差])：生成公差的等差数列，随机从中取一个值
    random()：随机生成下一个实数，[0,1)，随机概率
    shuffle(序列)：将序列中的元素随机排序
    uniform(x,y)：随机生成下一个实数，[x,y]
    randint(x,y)：随机生成下一个整数，[x,y]
'''

 

五、三角函数

'''
python包括以下三角函数：
1. acos(x)：返回x的反余弦弧度值。
2. asin(x)：返回x的反正弦弧度值。
3. atan(x)：返回x的反正切弧度值。
4. atan2(y, x)：返回给定的 X 及 Y 坐标值的反正切值。
5. cos(x)：返回x的弧度的余弦值。
6. hypot(x, y)：返回欧几里德范数 sqrt(xx + yy)。
7. sin(x)：返回的x弧度的正弦值。
8. tan(x)：返回x弧度的正切值。
9. degrees(x)：将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
10. radians(x)：将角度转换为弧度
'''

 

 字符串

字符串的运算

# 1.+：连接字符串
a, b, c = "好好学习", "Python", "，将来找份好工作！"
d = a + b + c
print(d)
print("{}{}{}".format(a, b, c))

# 2.*：重复字符串
print(a * 5)

# 3.[索引]：从左到右索引从0开始，通过索引获取字符串中的字符
content = "learn python!"
print(content[0])  # l
print(content[-1])  # !
print(content[-2])  # n
print(content[4])  # n

# 4.[开始索引:结束索引+1]：截取字符串的一部分
print(content[0:5])
print(content[:5])
print(content[6:13])
print(content[6:])

# 5.[::-1]：字符串反转
print(content[::-1])

# 6.in、not in：成员运算符
print("python" in content)
print("learn" not in content)

#不转义字符串，显示原始字符串，在字符串前加r
print("python\ngolang")  # \n表示换行
print(r"python\ngolang")
print(R"python\ngolang")

#转义字符，做相应输出显示的变化
# 二、转义字符
# 1.\'：转义单引号
s1 = '小明说:\'今天心情好！\''
print(s1)
s1 = '小明说:"今天心情好！"'
print(s1)

# 2.\"：转义双引号
s2 = "小明说:'今天心情好！'"
print(s2)
s2 = "小明说:\"今天心情好！\""
print(s2)

# 3.\n：换行符
print("python\njava")

# 4.\t：制表符
print("python\tjava")

# 5.\r：回车符
print("python\rjava") #python 字符串不显示，已经被回车隐藏掉

 三、字符串的内建函数

# 1.字符串.capitalize()：单词第一个字符串转化为大写
print("python".capitalize())

# 2.字符串.center(宽度[,填充符])：将字符串按宽度居中显示，两边填充符号，默认符号是空格
print("python".center(12))
print("python".center(12, "*"))

# 3.字符串.ljust(宽度[,填充符])：将字符串按宽度居左显示，右边填充符号，默认符号是空格
print("python".ljust(12))
print("python".ljust(12, "*"))

# 4.字符串.rjust(宽度[,填充符])：将字符串按宽度居右显示，左边填充符号，默认符号是空格
print("python".rjust(12))
print("python".rjust(12, "*"))

# 5.字符串.count(子字符串[,开始索引][,结束索引+1])：在字符串中查找子字符串出现的次数
content = "learn python!"
print(content.count("n"))
print(content.count("n", 3, 11))

# 6.字符串.encode('utf-8')：字符串编码为字节
bytes_s = "我爱学习Python！".encode("utf-8")
print(bytes_s)

# 7.字节.decode('utf-8')：字节解码为字符串
str_s = bytes_s.decode("utf-8")
print(str_s)

# 8.字符串.endswith(子字符串[,开始索引][,结束索引+1])：查找指定索引范围内的字符串是否是以子字符串结尾返回True/False
print("python".endswith("n"))
print("python".endswith("n", 0, 5))
print("python".endswith("o"))

# 9.字符串.startswith(子字符串[,开始索引][,结束索引+1])：查找指定索引范围内的字符串是否是以子字符串开头，返回True/False
print("python".startswith("p"))
print("python".startswith("p", 1))
print("python".startswith("y"))

# 10.字符串.find(子字符串[,开始索引][,结束索引+1)：在指定范围内的字符串中查找子字符串，找到返回子字符串出现的索引，没找到返回的是-1
print(content.find("python"))
print(content.find("python", 6))
print(content.find("python", 7))

# 11.字符串.index(子字符串[,开始索引][,结束索引+1)：在指定范围内的字符串中查找子字符串，找到返回子字符串出现的索引，没找到抛出异常
print(content.index("python"))
print(content.index("python", 6))
# ValueError: substring not found：子字符串没有被找到
# print(content.index("python", 7))

# 12.字符串.upper()：把字符串中的字母全部转化为大写
print("python".upper())

# 13.字符串.lower()：把字符串中的字母全部转化为小写
print("USA".lower())

# 14.字符串.isupper()：判断字符串中的字母是否都为大写，是True，否False
print("USA".isupper())
print("Usa".isupper())

# 15.字符串.islower()：判断字符串中的字母是否都为小写，是True，否False
print("python".islower())
print("Python".islower())

print("Python".swapcase())

# 23.字符串.title()：将字符串中所有的单词首字母大写
print("study python".title())

# 24.字符串.istitle()：判断字符串中所有的单词首字母是否大写
print("study python".istitle())
print("study python".title().istitle())

 

# 16.字符串.split(分隔符)：以分隔符拆分字符串为列表
print("苹果、香蕉、雪梨、西瓜".split("、"))

# 17."分隔符".join(序列)：以分隔符连接序列中的字符串
fruits = ("葡萄", "火龙果", "猕猴桃", "菠萝")
print("，".join(fruits))

# 18.字符串.replace(待替换的字符,替换成的字符)
print("study python".replace("python", "java"))
print("study python".replace("python", "java").replace("study", "learn"))

# 19.字符串.lstrip([字符，不传默认为空格])：去掉左边的空格或指定的字符
print("    python".lstrip())
print("* +-/python".lstrip("+ *-/"))

# 20.字符串.rstrip([字符])：去掉右边的空格或指定的字符
print("python    ".rstrip())
print("python* +-/".rstrip("+ *-/"))

# 21.字符串.strip([字符])：去掉两边的空格或指定的字符
print("    python    ".strip())
print("    python* +-/".strip("+ *-/"))

# 25.字符串.zfill(宽度)：返回0填充的字符串
for v in range(1, 101):
    print(str(v).zfill(3))

 

import re

strtest1 = '【水淀粉分】撒[旦法]【 []'
re.sub(r'[\[\]【】]','',strtest1)
'水淀粉分撒旦法 '

 

列表 

# 一、访问列表中的值
# 根据索引取值，从左到右从0开始，从右到左从-1开始
arr = [1, 2, 3, 4, 'a', 'b', 'c', 'd']

print(arr[0])
print(arr[5])
print(arr[-1])
print(arr[-3])

# 二、更新列表中的值
arr[0] = 100
arr[-1] = "D"
arr[5] = "B"
print(arr)

# 三、删除列表中的值
# [100, 2, 3, 4, 'a', 'B', 'c', 'D']
del arr[0]
del arr[0]
print(arr)

del arr[1], arr[1], arr[1]
print(arr)

# 四、列表的操作符
# 1.+：拼接列表
a, b = [1, 2, 3], ['a', 'b', 'c']
print(a + b)

# 2.*：重复列表
print(a * 3)

# 3.in、not in：身份运算符
print(1 in a)
print('C' not in b)

# 4.列表的截取
c = ["aaa", "bbb", "ccc", 3, 5, 8, 9]
print(c[0:3])
print(c[:3])
print(c[3:7])
print(c[3:])

# 5.列表的反转
print(c[::-1])

# 6.列表的复制：复制值，内存地址改变了
d = c
e = c[:]

print(id(c), id(d), id(e))
print(c, d, e)

c[0] = "AAA"
print(c, d, e)

# 五、嵌套列表
x, y = [1, 2, 3], [4, 5, 6]
z = [x, y]
print(z)
print(z[0][1])
print(z[1][-1])

# 1.len(列表)：查看列表的长度
f = [1, 6, 7, 10, 3, 5, 8, 9]
print(len(f))

# 2.max(列表)：查看列表中最大值
print(max(f))

# 3.min(列表)：查看列表中最小值
print(min(f))

# 4.list(序列)：将序列转化为列表
print(list((1, 2, 3)))
print(list(set("abcdef")))
print(list(dict(id=1, sex="男", name="张三")))

# 七、列表的内置方法
arr_empty = []
# 1.列表.append(元素)：往列表末尾追加元素
arr_empty.append(1)
arr_empty.append(2)
arr_empty.append(3)
arr_empty.append(1)
arr_empty.append(2)
arr_empty.append(3)
arr_empty.append(1)
arr_empty.append(2)
arr_empty.append(3)
print(arr_empty)

# 2.列表.count(元素)：统计列表中元素出现的次数
print(arr_empty.count(1))
print(arr_empty.count(2))

# 3.列表.extend(序列)：往列表末尾一次性添加序列中的所有元素
arr_empty.extend(['a', 'b', 'c', 'd'])
print(arr_empty)

# 4.列表.index(元素)：从列表中查找出元素第一次出现的索引
print(arr_empty.index(1))
print(arr_empty.index('a'))
print(arr_empty.index(3))
# print(arr_empty.index(-1))

# 5.列表.insert(索引,元素)：根据指定索引往列表中插入元素
arr_empty.insert(0, 100)
arr_empty.insert(2, 200)
print(arr_empty)

# 6.列表.pop([-1])：移除列表中的元素，默认移除最后一个
arr_empty.pop()
print(arr_empty)

arr_empty.pop(-3)
print(arr_empty)

# 7.列表.remove(元素)：移除列表中匹配元素的第一次出现位置的元素
arr_empty.remove(2)
print(arr_empty)

# 8.列表.reverse()：反转列表中的元素
arr_empty.reverse()
print(arr_empty)

# 9.列表.sort([函数])：对列表进行排序
arr_number = [3, 1, 2, 8, 9, 6, 7, 10]
print(arr_number)

# reverse=True：降序排序
arr_number.sort(reverse=True)
print(arr_number)

# reverse=False：升序排序
arr_number.sort(reverse=False)
print(arr_number)

# 10.列表.clear()：清空列表
arr_number.clear()
print(arr_number)

# 11.列表.copy()：复制列表
arr1 = [1, 2, 3, 4, 5]
arr2 = arr1.copy()
print(arr1, arr2)
print(id(arr1), id(arr2))
arr1[0] = 100
print(arr1, arr2)

 元组

"""
元组类型
一、访问元组中的元素
二、更新元组中的元素？
三、删除元组中的元素？
四、元组的操作符
五、操作元组的函数
"""

# 一、访问元组中的元素
tup1 = (1, 2, 3, 4, 5, 6)
print(tup1[0])
print(tup1[-1])
print(tup1[3])
print(tup1[-3])

# 二、更新元组中的元素？
# 元组中的元素是不允许被修改的
# TypeError: 'tuple' object does not support item assignment
# 类型错误：元组对象不允许修改元素
# tup1[0] = 100
arr1 = list(tup1)
arr1[0] = 100
print(tuple(arr1))

# 三、删除元组中的元素？
# 元组中的元素是不允许被删除的
# TypeError: 'tuple' object doesn't support item deletion
# 类型错误：元组对象不允许删除元素
# del tup1[0]
arr2 = list(tup1)
del arr2[0]
print(tuple(arr2))

# 四、元组的操作符
# 1.+：连接元组
t2, t3 = (1, 2, 3), ('a', 'b', 'c')
print(t2 + t3)

# 2.*：重复元组
print(t2 * 3)

# 3.in、not in：身份运算符
print(2 in t2)
print('c' not in t3)

# 4.元组的截取
t4 = t2 + t3
print(t4)
print(t4[0:3])
print(t4[:3])
print(t4[3:6])
print(t4[3:])

# 5.元组的反转
print(t4[::-1])

# 6.元组的复制，复制值，复制前后内存地址指向同一个
print(t4[:])
t5 = t4[:]
print(id(t4), id(t5))

# 五、操作元组的函数
t6 = (3, 1, 5, 6, 8)

# 1.len(元组)：查看元组的长度
print(len(t6))

# 2.max(元组)：查看元组中的最大值
print(max(t6))

# 3.min(元组)：查看元组中的最小值
print(min(t6))

# 4.tuple(序列)：将序列转化为元组
print(tuple([1, 2, 3, 4, 5]))
print(tuple(set("abcdef")))
print(tuple({"id": 1, "name": "张三"}))

集合

# -*- coding: utf-8 -*-

"""
集合类型
一、定义集合
二、更新集合
三、删除集合元组
四、集合的操作符
五、操作集合的函数
"""

# 一、定义集合
# 集合是一个无序元素不重复的序列
# 基本功能是进行成员关系测试和删除重复的元素
# 可以使用{}或者是set()函数创建集合
a = {1, 2, 3, 4, 5}
b = set("abcdef")

print(a)
print(b)

# 二、更新集合
a.add(6)
a.add(100)
a.add(88)
print(a)
a.add(6)
a.add(100)
a.add(88)
print(a)

# 三、删除集合元素
a.remove(100)
a.remove(1)
print(a)

# 四、集合的操作符
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}
print(a, b)
# 1.-：取差集
print(a - b)
print(b - a)

# 2.|：取并集
print(a | b)

# 3.&：取交集
print(a & b)

# 4.^：取不同时存在的元素
print(a ^ b)

# 5.in、not in：成员运算符
print(1 in a)
print(7 not in b)

# 五、操作集合的函数
c = a | b
# 1.len(集合)：查看集合的长度
print(len(c))
# 2.max(集合)：查看集合的最大值
print(max(c))
# 3.min(集合)：查看集合的最小值
print(min(c))
# 4.list(集合)：集合转化为列表
print(list(c))
# 5.tuple(集合)：集合转化为元组
print(tuple(c))
# 7.set(序列)：序列转化为集合、去重
print(set((1, 2, 3, 4, 5)))
print(set(['a', 'b', 'b', 'a']))

 字典

 一、访问字典的键值
# 第一种使用{}包裹定义
# 第二种使用dict()包裹定义
# 键值对的形式定义
student1 = dict(name="张三", age=18, sex="男")
student2 = {"name": "李四", "age": 20, "sex": "女"}
print(student1)
print(student2)

print(student1["name"], student1["age"], student1["sex"])

# 二、更新字典的键值
student1["name"] = "张三丰"
student1["age"] = 120
print(student1)
student1["height"] = 180
student1["weight"] = 70
print(student1)

# 三、删除字典的键值
del student1["age"]
print(student1)
del student1["height"], student1["weight"]
print(student1)

# 四、嵌套字典
# 列表嵌套字典
students = [
    dict(_id=1, name="张三", age=18),
    dict(_id=2, name="李四", age=19),
    dict(_id=3, name="王五", age=18),
    dict(_id=4, name="赵六", age=16),
    dict(_id=5, name="孙七", age=18),
    dict(_id=6, name="田八", age=17),
]
print(students)
# 字典嵌套字典
"""
班级
- 年级名称
- 班级名称
- 班主任老师
- 学生
"""
class1 = dict(
    year_name="一年级",
    class_name="2班",
    class_teacher="李老师",
    students=students
)
pprint(class1)

a = dict(a=1, b=2, c=3, d=4)
print(a)

# 1.字典.copy()：复制字典，复制了值，但内存地址改变了
b = a.copy()
print(id(a), id(b))
a["a"] = 100
print(a, b)

# 2.字典.get(键[,值None])：根据键获取值
print(a["a"])
print(a.get("e", "不存在键e！"))

# 3.字典.keys()：获取字典的所有键
print(a.keys())

# 4.字典.values()：获取字典的所有值
print(a.values())

# 5.字典.items()：获取字典的键值对
print(a.items())

# 6.字典.update(字典)：更新字典到字典中
a.update(dict(name="北京", year=2020))
print(a)

# 7.字典.pop(键)：根据键删除，返回删除的值
if "age" not in a:
    print("age不在字典中！")
    # del a["age"]

print(a.pop("name"))

# 8.字典.clear()：清空字典
a.clear()
print(a)