前置：Python帮助文档
一、面向对象
万物皆对象，描述一个对象需要属性和方法
内置对象类型：
- 整数、浮点
- 字符串
- 列表
- 元组
- 字典
- 集合
二、数据类型
2.1 整形、浮点型
查看数据类型：
print(type(1))
>>>
><class 'int'>
转换数据类型：
print(int(1.9))
>>>
1
查看内存地址：
print(id(3))
print(id(3.0))
print(id(3.00))
>>>
17000816
18836496
18836496
注意：
print(0.1+0.2)
>>>
0.30000000000000004
原因：
出现这种情况是由于Python中数值的计算是先将数值转换成二进制，再计算完成之后再转换为十进制。有些十进制的数在转换为二进制时没有确定的数，从而造成了计算问题。
解决方案：
使用一个能够四舍五入的内置函数round()
print(round(0.1+0.2,2))
>>>
0.3
但是round()依然不能完全解决这种问题，如
# 按正常的思路结果应该是1.235，而现在的结果是1.234
print(round(1.2345,3))
>>>
1.234
math模块：内置的数学函数
# 引入math模块
import math
# 查看math模块下的函数
print(dir(math))
# 调用函数
print(1 * math.pi)
2.2 字符串
查看ascii码：
print(ord("a"))
>>>
97
ascii码转字符：
print(chr(97))
>>>
"a"
查看二进制：
print(bin(97))
>>>
0b1100001
查看默认字符集 ：
import sys
print(sys.getdefaultencoding())
>>>
utf-8
查看字符长度：
print(len("蟒蛇"))
>>>
2
索引：
name = "Python"
# 根据索引得到对应字符
print(name[0])
print(name[-2])
>>>
P
o
切片：
a = "Python Book"
# 注意：第二个参数表示到哪个索引为止，不包含这个索引
print(a[0:10:2])
print(a[0::2])
print(a[0:10:3])
# 注意：从右向左切片
print(a[10:0:-1])
>>>
Pto o
Pto ok
Ph o
kooB nohty
接收用户输入：
name = input("你的名字")
print("你的名字是："+name)
根据字符查找索引：
str = "I'm learning python"
print(str.index("l"))
根据条件对字符串进行分割：
str = "I Like Python"
# 也可以根据索引分割
print(str.split(" "))
根据条件将字符串进行拼接：
str = "Don't Love Me"
list = str.split(" ")
print("-".join(list))
格式化输出字符串：
str = "I Love {0}".format("You")
print(str)
# ^ 表示居中，> 表示右对齐，< 表示左对齐
str = "This is {0:^5d} and This is {1:.2f}".format(8,2)
print(str)
2.3列表：
列表是个筐，什么都能装
定义
lst = []
print(type(lst))
元素特点
# 列表的元素可以是各种类型
ls = [1, 3.14, "c", []]
print(ls)
print(id(ls))
# 列表中的元素是有顺序的
ls = [3.14, 1, "c", []]
print(id(ls))
索引和切片
ls = [1,2,3,4,5,6,7,8]
print(ls[1:3])
基本操作
- 根据索引进行赋值：
ls = ["a", "b", "c", "d"]
ls[1] = 1
ls[2] = "p"
print(ls)
- 在末尾追加元素：
ls = ["a", "b", "c"]
ls.append("e")
print(ls)
>>>
['a', 'b', 'c', 'e']
- 在中间插入元素：
ls = ["a", "b", "c"]
ls.insert(2,"c")
print(ls)
>>>
['a', 'b', 'c', 'c']
- 在末尾追加可迭代对象：
ls = ["c", "d"]
ls2 = ["a","b"]
ls.extend(ls2)
print(ls)
ls3 = "Python"
ls.extend(ls3)
print(ls)
>>>
['c', 'd', 'a', 'b']
['c', 'd', 'a', 'b', 'P', 'y', 't', 'h', 'o', 'n']
- 根据索引删除元素：
# 根据索引删除元素，并将其返回
ls = [1,2,3]
print(ls.pop(1))
print(ls)
>>>
2
[1, 3]
- 根据元素删除元素：
# 根据值删除对应元素，如果有多个对应元素则删除第一个
ls = ["b","o","a","o","k"]
print(ls)
>>>
['b', 'a', 'o', 'k']
- 清空列表：
ls = ["a",1]
ls.clear()
print(ls)
>>>
[]
- 排序：
# 排序：元素类型相同的列表才能排序
ls = ["a","d","A","c","B"]
ls2 = [1 ,2 ,5 ,4 ,3 ,2.5]
ls.sort()
# 由大到小排序
ls2.sort(reverse=True)
print(ls)
print(ls2)
>>>
['A', 'B', 'a', 'c', 'd']
[5, 4, 3, 2.5, 2, 1]
- 反向：
ls2 = [1 ,2 ,5 ,4 ,3 ,2.5]
# 从右向左输出，与大小、类型无关
ls2.reverse()
print(ls2)
- 拷贝：
# 拷贝
ls1 = [1, 2]
ls2 = ls1.copy()
print(ls2)
ls1 = [1, 2, [3, 4]]
# copy：浅拷贝，只拷贝第一层。第一层的元素发生变化时，复制体不会发生变化。但第二层元素变化时，复制体也跟着变化
ls2 = ls1.copy()
# copy.deepcopy：深拷贝，与本体没有任何关系，但需要引入copy
ls3 = copy.deepcopy(ls1)
ls1[0] = 100
print(ls2)
ls1[2][0] = 5
print(ls2)
print(ls3)
>>>
>[1, 2]
[1, 2, [3, 4]]
[1, 2, [5, 4]]
[1, 2, [3, 4]]
2.4 元组
元组与列表的区别
1）定义元组时，如果元组内只有一个元组，那么在第一个元组后面要加上逗号,
2）元组不支持修改，如果想要修改元组里面的元素，可以先将元组转换成列表，修改之后再转回元组。
3）元组的运行速度比列表快
- 定义：
a = (1,)
print(type(a))
# 元组不支持修改
tup = (1,2)
tup[0] = 100
print(tup)
>>>
<class 'tuple'>
Traceback (most recent call last):
File "E:\PythonProject\venv\元组.py", line 7, in <module>
tup[0] = 100
TypeError: 'tuple' object does not support item assignment
Process finished with exit code 1
基本操作
元组也是个序列，所以有些基本操作与列表是一样的，比如根据索引取值，拼接之类的
2.5 字典
定义
字典是一由键值对组成，其中键不可重复，而且必须是不可变元素（数字、字符串、元组）。
dic = {}
print(type(dic))
dic = dict()
print(type(dic))
>>>
<class 'dict'>
<class 'dict'>
基本操作
- 取值：
dic = {"name":"LXP","age":26,"city":"DaLian"}
print(dic["name"])
>>>
LXP
- 修改：
dic = {"name":"LXP","age":26,"city":"DaLian"}
dic["name"] = "CYM"
print(dic["name"])
>>>
CYM
- 读取不存在的键值对：
# 这是我在教学视频中看到的代码，可以运行。但是我使用时报错，不知道是不是版本原因
#dic = {[("name","LXP"),("age","26")]}
# 经过实验后这种写法可以达到同样的效果，下面是这种写法的分析
# 1.首先，经过实验字典里嵌套元组这种写法是不行的
# 2.[]是列表，列表中的元素是可变的，这样做可以追加或删除字典中的键值对
# 3.()是元组，元组中的数据是不可修改的，这样可以保护键值对,但是实际测试中依然可以修改，不知道是哪里错了
dic = dict([("name","LXP"),("age","26")])
print(dic["name"])
# 读取不存在的键会报错
#print(dic["city"])
# 元组名.get(参数1：键名,参数2：当键名不存在时返回的值)，作用是避免读取不存在的键时报错，让程序继续运行下去
print(dic.get("city","DaLian"))
print(dic)
# 元组名.setdefault(参数1：键名,参数2：当键名不存在时插入的值),作用是当查询的键不存在时在字典后追加这个键值对
print(dic.setdefault("city","Dalian"))
print(dic)
# 取键和值
dic = {"中国":"北京","韩国":"首尔","俄罗斯":"莫斯科"}
for p,v in dic.items():
print(p,v)
>>>
LXP
DaLian
{'name': 'LXP', 'age': '26'}
Dalian
{'name': 'LXP', 'age': '26', 'city': 'Dalian'}
中国 北京
韩国 首尔
俄罗斯 莫斯科
修改字典：
没根据键直接赋值与Update方法的区别： Update没有的键值对可以增加，根据键赋值的方法不行
dic = dict([("name","LXP"),("age","26")])
dic1 = {"age":"29"}
dic.update(dic1)
print(dic)
>>>
{'name': 'LXP', 'age': '29'}
- 删除：
dic = dict([("name","LXP"),("age","26")])
del dic["name"]
print(dic)
# 删除键值对的同时返回这个键的值
dic = dict([("name","LXP"),("age","26")])
print(dic.pop("name"))
print(dic.pop("name","没有这个键"))
# 删除字典中最后一个键值对，并将这个键值对返回
# Python3.6之前，字典里的键值对是随机排列的，所以删除也是随机的
dic = dict([("name","LXP"),("age","26"),("city","Dalian")])
print(dic.popitem())
>>>
{'age': '26'}
LXP
没有这个键
('city', 'Dalian')
- 比较字典和列表：
1）字典不是序列，尽管Python3.6以后字典有了顺序但依然不是序列
2）两者都是容器
3）两者都是可变对象
2.6集合
集合的基本知识
- 可变集合的定义
1）使用{}定义，但里面的元素不是键值对
2）集合中的元素没有重复的
3）集合中的元素是可哈希类型（可哈希：不可变元素，如字符串、元组、对象集；不可哈希：可变元素，如列表、字典、集合）
4）无序性 - 不可变集合的定义
1）变量名 = frozenset() - 集合的特点
集合没有索引、切片、重复、连接的特性，集合只有成员操作符、迭代循环遍历、枚举的特性
集合的方法
- 添加：
s = {1, 2, 3}
s.add("Python")
print(s)
>>>
{'Python', 1, 2, 3}
- 删除随机排序后的第一个元素：
s = {1, 2, 3}
s.pop()
print(s)
>>>
{2, 3}
- 删除指定元素：
# remove与discard的区别：remove删除不存在的元素会报错，而discard不会
s = {1, 2}
s.remove(3)
print(s)
s.discard(3)
print(s)
>>>
Traceback (most recent call last):
File "E:\PythonProject\venv\集合.py", line 18, in <module>
s.remove(3)
KeyError: 3
- 集合的关系和运算：
s1 = {1, 2, 3, 4, 5}
s2 = {1, 2, 3}
# 判断超集
print(s1.issuperset(s2))
print(s2.issuperset(s1))
# 判断子集
print(s1.issubset(s2))
print(s2.issubset(s1))
# 查看两个集合的并集
print(s1 | s2)
print(s1.union(s2))
# 查看两个集合的交集
print(s1 & s2)
print(s1.intersection(s2))
# 查看两个集合的差集
print(s1 - s2)
print(s1.difference(s2))
>>>
True
False
False
True
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}
{1, 2, 3}
{1, 2, 3}
{4, 5}
{4, 5}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
