目录结构：

• Python中的内置数据类型
• 常用两种数据类型的操作
• 类型特点与使用总结

一、Python中的内置数据类型

• 数字（Number）关键字: int 、float、complex
• 字符串（String）关键字：单引号，双引号 三引号都可以表示，8 种内置类型都可转为字符串类型
• 列表（List） 关键符号 []，可变长度
• 元组（Tuple）关键符号 ()，不可变长度，多用于函数返回
• 集合（Set）关键符号 {}，具有唯一性
• 字典（Dictionary） 语法格式：{key:value，...} ，默认值

数字（Number）

• 数字是Python中最基础和最常见的数据类型之一。
• Python3 中有三种数值类型：整数、浮点数和复数。
• 在Python中，整数是没有大小限制的，浮点数也可以表示为科学计数法形式，而复数则包含了实部和虚部两个部分。

# 整型
a = 100
print(type(a))  # <class 'int'>
 
# 浮点型
b = 1.23e9
print(type(b))  # <class 'float'>
 
# 复数型
c = 1 + 2j
print(type(c))  # <class 'complex'>

数字在计算机语言中具有很重要地位，在各种算法和应用场景中都有广泛的应用。数字类型在实际编程中也会出现一些问题，如浮点数的精度问题、整数溢出等。

字符串（String）

• 字符串是Python中最常用的数据类型之一，通常用于表示文本和字符序列。
• 在Python中，字符串可以使用单引号、双引号、三引号等多种方式进行定义和表示，并且支持各种常见的字符串操作，如切片、拼接、替换等。

# 单引号方式定义
a = 'Hello World'
print(a)
 
# 双引号方式定义
b = "Python is awesome."
print(b)
 
# 三引号方式定义，可包含换行符
c = '''This is a multi-line string.
It can cover multiple lines.'''
print(c)
 
# 字符串拼接
d = a + b
print(d)
 
# 字符串切片
e = d[:5]
print(e)

字符串作为计算机语言中基本数据类型之一，其在各种应用场景中具有重要的地位。例如，在文本处理、Web开发、数据科学等领域中都大量使用到了字符串操作。

列表（List）

• 列表是Python中最灵活和最常用的数据类型之一。
• 它可以容纳任意数量的元素，同时支持多种操作（如添加、删除、更新、查找等）。
• 在Python中，列表可以通过方括号“[]”来进行定义和表示。列表中的元素可以是任意类型，包括数字、字符串、甚至是其他列表和复杂数据类型。

# 列表定义
a = [1, 2, 3, 4, 5]
print(a)
 
# 列表操作
a.append(6)  # 添加元素
print(a)
 
a.remove(4)  # 删除元素
print(a)
 
a[0] = 0  # 更新元素
print(a)
 
b = ['apple', 'banana', 'orange']
c = a + b  # 拼接列表
print(c)

由于列表具有很高的灵活性，在Python语言中被广泛应用到各种场景中。例如，在Web开发、机器学习、数据分析等领域中，几乎都需要使用到列表来存储和处理数据。

元组（Tuple）

• 元组与列表类似，也可以容纳任意数量的元素，但是它们之间存在着一些重要的区别。
• 在Python中，元组使用圆括号“()”来进行定义和表示。与列表不同的是，元组一旦定义完成后就无法再进行修改；同时，元组也没有像列表那样多种灵活的操作。

# 元组定义
a = (1, 2, 'apple', 'banana')
print(a)
 
# 访问元组中的值
b = a[2]
print(b)
 
# 尝试修改元组会报错：TypeError: 'tuple' object does not support item assignment
a[0] = 0

由于元组具有不可变性的特点，在Python语言中被广泛运用到需要传递不可变参数或者保证不修改数据的场景中。例如，在函数内部传递参数时，使用元组可以避免在函数内部对参数值的修改。

集合（Set）

• 集合是Python中一种常见的数据类型，它可以容纳任意数量的元素，并且同时保证每个元素都是唯一的。
• 在Python中，集合使用大括号“{}”或者“set()”来进行定义和表示。集合支持很多类似于数学上集合操作（如并集、交集、差集等），同时也提供了类似列表的添加、删除等操作。

# 集合定义
a = {1, 2, 3, 4, 5}
print(a)
 
# 集合去重
b = [1, 2, 2, 3, 4]
c = set(b)
print(c)
 
# 集合操作
s1 = {1, 2} 
s2 = {2, 3}
 
# 并集
s3 = s1 | s2  
print(s3)  
 
# 交集
s4 = s1 & s2  
print(s4) 
 
# 差集
s5 = s1 - s2  
print(s5)

由于集合具有去重和快速元素查找的特点，在Python语言中被广泛运用到需要保证元素唯一和数据查找效率的场景中。例如，在数据科学、财务分析等方面，使用集合可以有效地去重和剔除异常值。

字典（Dictionary）

• 字典是Python中最常用的数据类型之一，它可以容纳任意数量的键值对，并且支持类似列表的多种操作（如添加、删除、更新等）。
• 在Python中，字典使用大括号“{}”来进行定义和表示。字典中的键值对可以是任意类型，包括数字、字符串、元组等；同时，字典也提供了很多类似于列表的操作（如切片、拼接等）。

# 字典定义
a = {'name': 'Alice', 'age': 20, 'gender': 'female'}
print(a)
 
# 访问字典中的值
b = a['name']
print(b)
 
# 更新字典
a['age'] = 21
print(a)
 
# 字典操作
b = {'location': 'China', 'hobby': ['reading', 'swimming']}
c = {**a, **b}  # 合并字典
print(c)

由于字典具有快速查找和管理键值对的功能，在Python语言中被广泛运用到各种应用场景中。例如，在Web开发、机器学习、数据分析等领域中，几乎都需要使用到字典来存储和处理数据。

二、数据类型的操作

通用基础操作

• 1. 类型的内置方法
     py的数据类型的内置方法统一使用 "句点符“表达。

数据类型.方法名()

例：
name = 'carmen'
name.strip()

用pycharm等开发工具，在编辑处输入 "." 会有将内置方法联想带出，方便开发
并不是所有的类型都有内置方法

• 2. 输出类型的函数
     type()
     功能：数据类型输出
     举例：

# 注意以下两者输出的类型不同，前者为int，后者为str
print(type(int(123)))
print(type(int('123')))

• 3. 类型转换函数
     功能：实现类型的转换

- int() 转int型
- str() 转字符串形
- float() 转符点型

字符串操作介绍

• 类型转换
  内置的8点数据类型都可以转为字符串类型，原理就是将所以数据值打上一个引号即可。
• 索引取值

s1 = 'hello carmen!'
# 索引取值:单个字符  支持负数
print(s1[0])  # h       # 索取第一个值[0]
print(s1[-1])  # !      # 索取最后一个值[-1]
print(s1[-2])  # n      # 索取倒数第二个值[-2]

• 3.切片取值

s1 = 'hello carmen!'
print(s1[0:3])       # 从索引0的位置开始切到索引2的位置 顾头不顾尾
print(s1[-1:-4])     # 切片的顺序默认从左往右
print(s1[-1:-4:-1])      #!ni 可以通过第三个参数的正负一 控制方向
print(s1[-4:-1])     # 顾头不顾尾

-------- 控制台输出结果 --------
hel

ne
men

在pycharm上创建一个py，试着复制上方的语句试试

4.间隔/方向

s1 = 'hello carmen!'
print(s1[:])  # hello carmen!       默认取值所有
print(s1[::2])  # carmen!           针对整个字符串 隔一个取一个
print(s1[0:5:1])  # hello           默认1可以不写
print(s1[0:5:2])  # hlo

------------------ 控制台输出 ---------
s1 = 'hello carmen!'
print(s1[:])      # hello carmen!         默认取值所有
print(s1[::2])    # carmen!               针对整个字符串 隔一个取一个
print(s1[0:5:1])  # hello                 默认1可以不写
print(s1[0:5:2])  # hlo

5.统计字符串中字符个数

s1 = 'hello carmen!'        # 注意空格也算一个
print(len(s1))              # 关键字 len

6.移除字符串首尾指导的字符

count = '??meijin??'
print(count.strip('?'))  # meijin
print(count.lstrip('?'))  # meijin??      L消除左边的符号
print(count.rstrip('?'))  # ??meijin      R消除右边的符号

7.按照指定的字符切割字符串

info = 'jason|123|read'                     # 当字符串中出现了连续的特征符号 应该考虑使用切割操作
res = info.split('|')                       # 切割字符串之后结果是一个列表
print(res, type(res))                       # ['jason', '123', 'read'] <class 'list'>
name, pwd, hobby = info.split('|')          # name, pwd, hobby = ['jason', '123', 'read']
print(info.split('|', maxsplit=1))          # 从左往右 只切一次  ['jason', '123|read']
print(info.rsplit('|', maxsplit=1))         # 从右往左 只切一次  ['jason|123', 'read']

8.字符串大小写

s2 = 'hello carmen 666 你给我点个赞啊'
print(s2.lower())   # hello carmen 666 你给我点个赞啊
print(s2.upper())    # HeLLo MEIJIN 666 你给我点个赞啊
print(s2.islower())      # 判断字符串中所有的字母是否是全小写  False
print(s2.isupper())      # 判断字符串中所有的字母是否是全大写  False
print('aaa'.islower())  # True
print('AAA'.isupper())  # True

9.字符串的格式化输出

res1 = 'my name is {} my age is {}'  # 方式1: 等价于%s占位 没有什么优势
print(res1.format('jason', 18))

res2 = 'my name is {0} my age is {1} {0} {1} {1} {1}'  # 方式2: 支持索引取值 并且支持重复使用
print(res2.format('jason', 18))

res3 = '{name} {name} {age} my name is {name} my age is {age}'  # 方式3: 支持关键字取值(按k取值) 并且支持重复使用
print(res3.format(name='jason', age=18))

name = 'jason'  # 方式4:推荐使用(******)
age = 18
print(f'my name is {name} my age is {age} {name} {age}')

10.统计字符串中指定字符出现的次数

res = 'meijinhaoshuaiawodeouxiangyajiushimeijin'
print(res.count('i'))  # 字符串中有多少i
print(res.count('a'))  # 字符串中有多少a

11.判断字符串的开头或者结尾

res = 'jason say ha ha ha heiheihei'
print(res.startswith('jason'))  #True 开头是不是jason  
print(res.startswith('j'))  #True 开始字母是不是j    
print(res.startswith('b'))  #False 开头字母是不是b
print(res.endswith('heiheihei'))  #True  结尾是不是heihehiehi
print(res.endswith('hei'))  #True 结尾是不是hei
print(res.endswith('h'))  #False 结尾是不是h

12. 字符串的替换

res = 'carmen carmen carmen SB SB SB'
print(res.replace('carmen', 'tony'))  # 从左往右全部替换
print(res.replace('carmen', 'tony', 1))  # 从左往右替换指定1个数
# ---控制台输出结果如下--
tony tony tony SB SB SB
tony carmen carmen SB SB SB

13.字符串的拼接

res1 = 'hello'
res2 = 'world'
print(res1 + res2)  # 字符串支持加号拼接
print(res1 * 10)  # 字符串支持乘号重复
print(''.join(['hello', 'world', 'hahaha']))  # join方法拼接
print('|'.join(['hello', 'world', 'hahaha']))  # join方法拼接
print('$'.join(['carmek', 'say', 666]))  # 列表中的数据都必须是字符串类型  报错!!!

14.判断字符串中是否是纯数字

print('123'.isdigit())  # True
print('123a'.isdigit())  # False
print(''.isdigit())  # False

15.查找某个字符对应的索引值

res = 'hello world jason'
print(res.index('d'))  # 10
print(res.find('d'))  # 10
'''index查找索引 如果没有则报错'''
# print(res.index('d',0,5))
'''find查找索引 如果没有则返回-1'''
print(res.find('d', 0, 5))  # -1

列表 list

• 1.数据类型转换

print(type(list(123)))  # 整型
print(type(list(123.22)))  # 浮点型
print(type(list('123243jasdsad')), list('123243jasdsad'))  # 字符串
print(type(list({'name': "jason", 'pwd': 123})), list({'name': "jason", 'pwd': 123}))  # 字典

• 2.索引取值

l1 = ['jason', 'kevin', 'oscar', 'tony']
print(l1[0])  # 取第一个值
print(l1[-1])  # 去倒数第一个值    同理列表

• 3.切片操作

l1 = ['jason', 'kevin', 'oscar', 'tony']
print(l1[0:3])  # 只取三个数据值
print(l1[:])  # 不输入默认全部
print(l1[-4:-1])  # 可以反方向取值

• 4.间隔/方向

l1 = ['jason', 'kevin', 'oscar', 'tony', 'tom']
print(l1[::2])  # 各两个数据值取值

• 5.统计列表中数据值的个数

l1 = ['jason', 'kevin', 'oscar', 'tony', 'tom']
print(len(l1))  # 统计l1列表中有多少个数据值

Python 类型特点

动态类型

Python中的数据类型是动态类型。

在使用Python内置数据类型时应注意它们的特性和使用方法，并根据实际场景选择最适合的数据类型。此外，需要注意Python中的数据类型是动态类型，因此变量的数据类型可以在运行时更改，但这也会带来一些潜在的问题和风险。

类型的可变性和不可变性。

可变性和不可变性是Python中内置数据类型之间最重要的区别之一。在Python中，列表、集合和字典都属于可变对象；而数字、字符串和元组则属于不可变对象。由于这个区别带来的巨大差异，广泛地影响着它们在 Python 代码中的运用。

. 容器类型和标量类型

容器类型和标量类型是另一个重要的分类方式。具体来说：容器类型是指可以包含多个元素的对象，例如列表、元组、集合和字典； 而标量类型则是指只能包含单个元素的对象，例如数字和字符串等。

在许多场景中，这种区别具有重要意义。例如，在执行计算时，列表和提供了灵活性，但也会带来额外的开销以及一些潜在的错误；而标量类型则可能更加高效。

类型默认值

在Python中，许多内置数据类型都支持缺省值（默认值）。这意味着，当我们创建一个数据结构时，可以为其中的元素指定一个默认值，在不设置具体值时就会使用这个默认值。这种机制可以帮助我们更好地管理和处理数据结构，并且避免出现未定义的错误。

• 数据字典的默认值
  可以使用字典类型的 setdefault() 方法来设置键值对的默认值：

d = {}
d.setdefault('age', 18)

在这个例子中，我们为字典 d 中的键 'age' 设置了缺省值 18。如果我们后续再添加键 'name'，但age没有旨定新值，则age会自动使用该字典的缺省值：

d['name'] = d.get('name', 'Alice')
print(d)     
# ---------- 控制台输出结果为 ----------
# {'age': 18, 'name': 'Alice'}

类型运算符重载

Python支持通过重载运算符来改变内置数据类型的行为。具体来说，我们可以通过定义类方法来覆盖默认行为，并且实现自定义逻辑。

例如，在使用自定义类时，我们可以重载加号运算符 add（+）并且定义自己的逻辑：

class MyNumber:
    def __init__(self, value):
        self.value = value
        
    def __add__(self, other):
        return MyNumber(self.value + other.value)
      
a = MyNumber(10)
b = MyNumber(20)
c = a + b
print(c.value) # 30

六、类型总结

1. Python的内置数据类型包括数字（int, float, complex）、字符串（str）、布尔值（bool）、列表（list）、元组（tuple）、集合（set）和字典（dict）等。
2. 数字类型具有不同的表示形式和精度，其中int 表示整数，float 表 示浮点数，complex表示复数。
3. 字符串类型是以字符序列的形式表示的文本数据，可以使用单引号、双引号或三引号来定义。
4. 布尔值类型只有True和False两个常量值，用于表示真假值。
5. 列表类型是一种有序的数据集合，元素可以是任意数据类型，并且可以进行增删改查等操作。
6. 元组类型与列表类似，但元素不可变。因此，元组通常用于需要固定结构的场景中。
7. 集合类型是一种无序、唯一的数据集合，可以进行交集、并集、差集等操作。
8. 字典类型是一种键值对结构，在访问和更新时以键为索引而不是下标进行操作。
9. 除了基本数据类型外，Python还支持许多标准库和第三方库提供的高级数据结构，如numpy中的数组、pandas中的数据框等。
10. 在Python语言中，不同内置数据类型的选择取决于具体的应用场景。

例如，当我们需要对一组元素进行序列化操作时，通常会选择使用列表或者元组；而当我们需要筛选出唯一元素时，则可以使用集合。

11. 在某些应用场景下，不同的内置数据类型可能存在明显的性能差异。

例如，在执行较长迭代计算时，因为快速随机访问列表比遍历字典更快速，在这种情况下建议选择列表。但在其他情况下，字典或集合等更适合实现高效的计算。在选择内置数据类型时，需要根据实际情况和需求来进行选择。