学习笔记之Python的六种内置对象
2024-04-10 06:46:33
前置：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 assignmentProcess 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}
学习笔记之Python的六种内置对象相关推荐
- JSP学习 三大指令、九个内置对象、JavaBean、EL表达式
1.page-->最复杂:<%@page language="java" info="xxx"...%>* pageEncoding和cont ...
- 《JavaScript高级程序设计》读书笔记（十一）：内置对象Global
内置对象 定义:由ECMAScript实现提供的.独立于宿主环境的所有对象,在ECMAScript程序开始执行时出现. 由定义可知开发者不必明确实例化内置对象,它已被实例化了.在ECMAScript- ...
- python学习笔记（07）---（内置容器-字典）
第七章 内置容器(三) 4.字典 (1)概念:字典属于可变序列,使用"键 : 值"(key-value)的方式配对存储数据,类似拼音-汉字的映射关系 (2)格式:dictname ...
- 【学习笔记】16、常用内置函数（Built-in Functions）
常用内置函数(Built-in Functions) 可以参照中文版文档:Python3 内置函数 | 菜鸟教程 常用的内置函数可以做如下分类: 1.数据类型相关 type() – 取数据类型 int ...
- python常用的内置对象有哪些_#【Python】【基础知识】【内置对象常用方法】
数字的常用方法: >>>dir(int) ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', ...
- python语言的内置对象类型_Python内置对象类型
核心数字类型: 数字:int,long,float,complex,bool 字符:str,unicode 列表:list 字典:dict 元组:tuple 文件:file 其他类型:集合(set), ...
- dict是python语言的内置对象_Python内置了字典：dict的支持
一.dict函数 如果用dict实现,只需要一个"名字"-"成绩"的对照表,直接根据名字查找成绩,无论这个表有多大,查找速度都不会变慢.用Python写一个di ...
- 十月二日读书笔记（JSP网页的内置对象）
1 request request对象用于获取客户端发来的请求信息,包括HTTP报文和网页发来的信息.例如,要获取以下表单控件的信息: <form action = "acceptio ...
- 下面属于python内置对象的有哪些_Python内置对象实现的方法及注意事项
 (W3shool JS手册地址:http:// ...
最新文章
- Exchange Technical community discussion group
- PHP Log时时查看小工具
- 信息系统项目管理师-招投标法、政府采购法核心知识点思维脑图
- zcmu2165（分组背包）
- java冗余_Java使用lombok消除冗余代码的方法步骤
- Linux常用命令汇总--ln
- geant4运行例子_Geant4--一次编译，运行多个Run，极大提升模拟效率
- Linux之软件安装YUM
- mfc chartctrl 饼状图编写_鸡蛋饼
- linux wegt克隆网站,linux利用wget命令备份网站（镜像拷贝）
- swift-自定义Alert
- power designer 连接数据库以及 Could not Initialize JavaVM! 错误的解决
- 元胞自动机（又称细胞自动机）
- 飞鸽传书2011下载(飞鸽传书)
- ubuntu 12.04 安装 Anjuta
- 数据质量管理方法有哪些
- Goonie企业竞争情报系统评为选中国优秀网络应用软件奖
- 网关统一配置解决跨域问题
- XMind基础教程-主题篇
- 【Unity3D-UGUI应用篇】（六）屏幕自适应(多分配率适配)