第三章：一篇搞定Python基本数据类型和内置方法

于 2021-01-22 14:04:48 发布
阅读量140 收藏 1
点赞数
分类专栏： Python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41405475/article/details/112983460
版权
本文详细介绍了Python的基本数据类型，包括数字（整型、浮点型）、字符串、列表、字典、元组和集合，以及它们的内置方法。内容涵盖类型转换、操作、成员运算、切片、长度计算等核心概念，帮助读者全面理解Python的数据结构和操作技巧。
摘要由CSDN通过智能技术生成

文章目录

第三章 一篇搞定Python基本数据类型和内置方法

一、数字类型

1.1整型(int)

# 整型用来记录年龄、事物个数等。
age = 18
print(age)
print(type(age))
number = 9 * 9
print(number)
print(age > number)

# int可以将由纯整数构成的字符串直接转换成整型，如果包含其他任意非整数符号，则会报错
s1 = '999'
s2 = int(s1)
print(s2)
print(int('wuchangwen666'))  # 报错，除了纯整数构成的之外都不可以转换
print(int('3.13'))   # 报错，字符串内包含了非整数符号.

1.2浮点型(float)

# 浮点型用来记录人的体重、身高等
height = 1.8
print(height,type(height))
salary = 3.1
print(salary)
pai = 3.14
print(pai)
p = 3.13 * 3 * 4
print(p)

# float同样可以用来做数据类型的转换
s1 = '3.14'
s2 = float(s1)
print(s2,type(s2))

print(float('666'))

二、字符串类型(String)

2.1 基本概念(不可变、有序)

# 字符串主要用来记录具有描述性的事物，如：名字、一句话、一段话等。
str01 = '这是字符串01'
print(str01)
str02 = "这是字符串02"
print(str02)

# 三引号可以写多行字符串
str03 = '''
这是字符串03
这是字符串03
这是字符串03
'''
print(str03)

str04 = """
这是字符串04
这是字符串04
这是字符串04
"""
print(str04,type(str04))

2.2 字符串的常用内置方法

#1.类型装换：字符串可以把任意数据类型转换成字符串类型
print(type(str(3.14)))  # float转成str
print(type(str(18)))    # int => str
print(type(str([1,2,3,'abc'])))  # list => str

# 2.索引取值 (只能取，不能修改！)
str01 = 'I love learning'
#索引顺序:0123456789...  
# 正向取(从左往右)
print(str01[6])
# 反向取(从右往左)
print(str01[-7])

# 3.切片
str02 = 'Dream is beautiful'
str03 = str02[1:6:1]
print(str03)  #ream 
str04 = [0:5:2]
str04 = str02[0:5:2]
print(str04)  # Dem
str05 = str02[0:5]
print(str05)  # Dream
str06 = str02[0:]
print(str06)  # Dream is beautiful
str07 = str02[:5]
print(str07)   # Dream
str08 = str02[::1]
print(str08)   # Dream is beautiful
str09 = str02[:]
print(str09)  # Dream is beautiful
s1 = '乘风破浪会有时,直挂云帆济沧海'
print(s1[-1:-3:-1])
print(s1[-1::-1])
print(s1[::-1])

# 4.长度(len)
s1 = 'hello，world'
print(len(s1))

# 5.成员运算in与not in
s1 = 'hello,world'
print('hello' in s1)
print('hello'not in s1)

# 6.移除空白(strip)
# 括号内不指定字符，默认移除首尾空格
s1 = '   hello,world     '
print(s1.strip())
# 括号内指定字符，移除首尾指定的字符
s1 = '****hello,world****'
print(s1.strip(*))

# 7.切分(split)
s1 = 'hello world'
print(s1.split(,))
s2 = 'hello,world'
print(s2.split(,))

# 8.拼接(join)
print('*'.join('123456'))

# 9.替换(replace)
s1 = 'My age is 81'
print(s1.replace('81','18'))

# 10.大小写lower(),upper()
s1 = 'My Name is Wuchangwen'
print(s1.lower())
print(s1.upper())

三、列表类型(List)

3.1 基本概念(可变、无序)

# 列表是用[]按照顺序把多个任意类型的值放在一起
num_lsit = [1,2,3,4,5,6,7,8,9]
print(num_list,type(num_list))

info_list = ['吴常文',18,'男',{'爱好':['学习','跑步','乒乓球']}]
print(info_list)

3.2 列表的常用内置方法

# 1.索引(可存可取)
students_list = ['小明','杰克','马克','玛利亚','丽丽','欣欣']
print(students_list[0])
print(students_list[-1])

# 2.切片
students_list = ['小明','杰克','马克','玛利亚','丽丽','欣欣']
print(students_list[0:3])
print(students_list[0:5:1])

# 3.长度(len)
students_list = ['小明','杰克','马克','玛利亚','丽丽','欣欣']
print()

# 4.类型转换
print(list('123456'))
print(list{'name':'wuchangwen','age':18})

# 5.添加(append、extend、insert)
students_list = ['小明','杰克','马克','玛利亚','丽丽','欣欣']
print(students_list)
students_list.append('小李')  # 追加元素且只可以追加一个
print(students_list)

# extend()一次性在列表尾部添加多个元素
l1 = ['a','b','c']
l1.extend(['a','b','c'])
print(l1)
src_l = [11, 22, 33]
names=['egon','jack','tom']
src_l.extend(names) 
src_l.extend("hello")
print(src_l)

students_list = ['小明','杰克','马克','玛利亚','丽丽','欣欣']
students_list.insert(-1,'last')   # insert()在指定位置插入元素
print(students_list)


# 6.成员运算in和not in
students_list = ['小明','杰克','马克','玛利亚','丽丽','欣欣']
print('小明' in students_list)
print('小明' not in students_list)

# 7.删除(del、pop、remove、)
students_list = ['小明','杰克','马克','玛利亚','丽丽','欣欣']
del students_list[3]  # 删除索引为3的元素
print(students_list)

# pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
students_list = ['小明','杰克','马克','玛利亚','丽丽','欣欣']
res = students_list.pop()
print(res)

# remove()括号内指名道姓表示要删除哪个元素，没有返回值
students_list = ['小明','杰克','马克','玛利亚','丽丽','欣欣']
res = students_list.remove('玛利亚')
print(res)  # None

四、字典类型(Dict)

4.1 重要概念(可变、无序)

# 按照属性存放多个值,在{}内用逗号分隔开多个key:value
#             其中value可以是任意类型
#             而key必须是不可变的类型,通常为字符串类型,并且key不能重复
info = {'name':'wuchangwen','age':18,'gender':'male'}
print(info)

4.2 字典常用的内置方法

# 1.类型转换
info = dict([['name','wuchangwen'],('age',18)])
print(info,type(info))

# 2.按key存取值：可存可取
dic = {'name':'wuchangwen','age':18}
print(dic['name'])
print(dic['nameasdfadf'])
res=dic.get('name')
print(res)

# key不存在则加元素，存在则改值
dic['gender'] = 'male'
print(dic)

# 3.长度len
dic = {'name':'wuchangwen','age':18}
print(len(dic))

# 4.成员运算in和not in=>依据key
dic = {'name':'wuchangwen','age':18}
print('name' in dic)
print('wuchangwen' in dic)

4、删除
dic = {'name': 'wuchangwen', 'age': 18}
# 方式1：万能删除，没有返回值
del dic['name']
print(dic)

# 方式2：pop指定key删除，返回删除的value
res = dic.pop('name')
print(res)

# 方式3：popitem
res=dic.popitem()
print(res)

# 6.键keys()，值values()，键值对items()
dic = {'name':'wuchangwen','age':18}
dic.keys()

C:\Users\wu先生>python2
Python 2.7.18 (v2.7.18:8d21aa21f2, Apr 20 2020, 13:25:05) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> dic = {'name':'wuchangwen','age':18}
>>> dic
{'age': 18, 'name': 'wuchangwen'}
>>>
>>> dic.keys()
['age', 'name']
>>> dic.values()
[18, 'wuchangwen']
>>> dic.items()
[('age', 18), ('name', 'wuchangwen')]
>>>

# 7.循环
dic = {'name':'wuchangwen','age':18}
for k in dic.keys():
    print(k)

print(list(dic.keys()))

for v in dic.values():
    print(v)

for k,v in dic.items():
    print(k,v)
    
# update
dic={'k1':111,'k2':2222}
dic.update({"k2":4444,'k3':5555})
print(dic)

dic={'age':18}

# if 'name' not in dic:
#     dic['name']="wuchangwen"

res = dic.setdefault('name',"wuchangwen")
# print(dic)
print(res)

五、元组类型(tuple)

5.1 重要概念(不可变，有序)

1.作用：按照索引/位置存放多个值，只用于读，不用于改
2.定义：
t = (1,1.3,'aaa')	#t = tuple((1,1.3,'aaa'))
print(t,type(t))
单独一个括号，代表包含的意思
x = (10)	#单独一个括号，代表包含的意思
print(x,type(x))
如果元组中只有一个元素，必须加逗号
x = (10,)	#如果元组中只有一个元素，必须加逗号
print(x,type(x))
t = (1,1.3,'aaa')	#t = (0->值1的内存地址，1->值1.3的内存地址，2->值'aaa'的内存地址，)
#只要元组内元素的内存地址没变，元组就是不可变
元组不能改，指的是不能改里面的内存地址
t = (1,[11,22])
print(t,id(t[0]),id(t[1]))
t[1][0] = 33		# 元组内的列表的元素还是可以改的
print(t,id(t[0]),id(t[1]))

(1, [11, 22]) 2038884272 59297864
(1, [33, 22]) 2038884272 59297864

5.2 元组常用的内置方法

# 1.类型装换
print(tuple('hello'))
print(tuple([1,2,3]))
print(tuple({'name':'wuchangwen','age':18}))

# 2.按照索引取值（正向取值 + 反向取值）只能取
t = (111, 'egon', 'hello')
# 正向取值
print(t[0])
# 反向取值
print(t[-1])
# 3.切片（顾头不顾尾，步长）
t = ('aa', 'bbb', 'cc', 'dd', 'eee')
print(t[0:3])
print(t[::-1])

# ('aa', 'bbb', 'cc')
# ('eee', 'dd', 'cc', 'bbb', 'aa')
# 4.长度
t = ('aa', 'bbb', 'cc', 'dd', 'eee')
print(len(t))  # 5

# 5.成员运算 in 与 not in 判断一个子字符串是否存在于一个大字符串中
t = ('aa', 'bbb', 'cc', 'dd', 'eee')  # True
print('aa' in t)


# 6.循环
t = ('aa', 'bbb', 'cc', 'dd', 'eee')
for x in t:
    print(x)

# aa
# bbb
# cc
# dd
# eee
# 7.index和count补充：
# index：找出该字符串在元组中的索引位置，找不到就会报错
t = (2, 3, 111, 111, 111, 111)
print(t.index(111))
print(t.index(1111111111))


# ValueError: tuple.index(x): x not in tuple
# count：统计该字符串在元组中出现的次数
t = (2, 3, 111, 111, 111, 111)
print(t.count(111))  # 4

六、集合类型(set)

6.1 重要概念(不可变)

作用：关系运算、去重
定义：在 {} 内通逗号隔开多个元素，多个元素满足以下条件：
1.集合内的元素必须为不可变类型
# s = {1,[1,2]}	# 错误,集合内的元素必须为不可变类型

TypeError: unhashable type: 'list'
2.集合内的元素无序
s = {1,'a','z','b',4,7}	 # 集合内元素无序

{1, 4, 7, 'z', 'b', 'a'}
3.集合内的元素没有重复
s = {1,1,1,1,'a','z','b',4,7}	 # 集合内的元素不能重复

{1, 'a', 4, 7, 'z', 'b'}
了解
s = {}	# 默认是空字典
print(type(s))
s = {1,2}	# s = set({1,2})
定义空集合：
s = set()
print(s,type(s))

类型转换
set({1,2,3})
res = set('hellollll')		# 可以去重
print(res)

{'e', 'o', 'h', 'l'}
print(set([1,1,1,1,1,1,1]))

{1}
print(set([1,1,1,1,1,1,1,[11,222]]))

TypeError: unhashable type: 'list'
print(set({'k1':1,'k2':2}))

{'k1', 'k2'}

6.2 集合常用的内置方法


# 1.关系运算符
# ① 取出交集：两者共同的好友
friends1 = {"wuchnagwen","wuchangchang","jack","tom"} # 用户1的好友们
friends2 = {"wuchangwen","tony","tom","mack"}   # 用户2的好友们
res = friends1 & friends2
res = friends1.intersection(friends2)
print(res)

# ② 取出并集/交集：两者所有的好友
friends1 = {"wuchnagwen","wuchangchang","jack","tom"} # 用户1的好友们
friends2 = {"wuchangwen","tony","tom","mack"}   # 用户2的好友们
res = friends1 | friends2
res = friends1.union(friends2)
print(res)

# ③ 取出差集：取出其中一个集合独有的好友
# 　　取出 friends1 独有的好友：

friends1 = {"wuchnagwen","wuchangchang","jack","tom"} # 用户1的好友们
friends2 = {"wuchangwen","tony","tom","mack"}   # 用户2的好友们
res = friends1 - friends2
res = friends1.difference(friends2)
print(res)


# 　　取出 friends2 独有的好友：

friends1 = {"wuchnagwen","wuchangchang","jack","tom"} # 用户1的好友们
friends2 = {"wuchangwen","tony","tom","mack"}   # 用户2的好友们
res = friends2 - friends1
res = friends1.symmetric_difference(friends2)
print(res)


# ④ 对称差集：求2个用户独有的好友们（即：去掉共同的好友）
friends1 = {"wuchnagwen","wuchangchang","jack","tom"} # 用户1的好友们
friends2 = {"wuchangwen","tony","tom","mack"}   # 用户2的好友们
res = friends2 ^ friends1
print(res)

# ⑤ 父子集：包含的关系
s1 = {1,2,3}
s2 = {1,2,4}
				# 不存在包含关系，下面比较均为False
print(s1.issupersets2())
print(s1 > s2)
print(s1 < s2)
s1 = {1,2,3}
s2 = {1,2}
print(s1.issubset(s2))
print(s1 > s2)		# 当s1大于或等于s2时，才能说s1是s2的爹
s1={1,2,3}
s2={1,2,3}
print(s1 == s2) # s1与s2互为父子


# ２.去重
# ① 只能针对不可变类型去重
print(set([1,1,2,2,2]))

# ② 无法保证原来的顺序
l = [1,'a','b',1,1,2,3]
l = list(set(l))
print(l)

[1, 2, 3, 'a', 'b']

# 3.长度
>>> s={'a','b','c'}
>>> len(s)

# 4.成员运算
>>> 'c' in s
True
# 5.循环
>>> for item in s:
...     print(item)
...
c
a
b
5.其他内置方法
.discard() —— 需要掌握
s = {1,2,3}
s.discard(4)    # 删除元素不存在，do nothing
print(s)
.remove()
s = {1,2,3}
s.remove(4)		# 删除元素不存在，则会报错
print(s)
.update() —— 需要掌握
s = {1,2,3}
s.update({1,3,5})
.pop() —— 需要掌握
s = {1,2,3}
res = s.pop()
print(res)
.add() —— 需要掌握
s = {1,2,3}
s.add(4)
print(res)

七、基本数据类型分类

7.1 按照存值个数区分

只能存一个值：可称为标量/量子类型数字、字符串
可以存放多个值：可称为容器类型列表、元组、字典

7.2 按照访问方式区分

只能存一个值：可称为标量/量子类型 数字
可以存放多个值：可以用索引访问指定的值，又称为序列类型 字符串、列表、元组
key访问：可以用key访问指定的值，又称为映射类型 字典

7.3 按照可变不可变区分

可变类型列表、字典
不可变类型数字、字符串、元组

作者：吴常文
出处：https://blog.csdn.net/qq_41405475
本文版权归作者和CSDN共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接。

xiao阿文
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xiao阿文

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值