【Python入门】Python数据类型

文章一览

• 前言
• 一、变量
• • 1.1.如何使用变量
  • 1.2.如何定义变量的名字（标识符）
• 二、数据类型
• • [2.1 整型数据](#2.1 整型数据)
  • [2.2 浮点型数据](#2.2 浮点型数据)
  • [2.3 布尔型（bool）数据](#2.3 布尔型（bool）数据)
  • [2.4 复数型数据](#2.4 复数型数据)
  • [2.5 字符串类型](#2.5 字符串类型)
  • • [1 > 字符串相加（合并）（+）](#1 > 字符串相加（合并）（+）)
    • [2> 字符串相乘（重复）（*）](#2> 字符串相乘（重复）（*）)
    • [3> 字符串相减（-）](#3> 字符串相减（-）)
    • [4> 成员运算符（in）](#4> 成员运算符（in）)
    • [5> 字符串切片](#5> 字符串切片)
    • [6> 用 字符串名`[索引号]` 索引字符串中的单个元素](#6> 用 字符串名[索引号] 索引字符串中的单个元素)
    • [7> 字符串切片模式](#7> 字符串切片模式)
    • [8> 字符串和数的转换](#8> 字符串和数的转换)
    • [9> 字符串也可以使用部分列表的成员函数](#9> 字符串也可以使用部分列表的成员函数)
  • 2.6列表(list)
  • • [1> **Python 里的列表形式：**](#1> Python 里的列表形式：)
    • [2> **列表（list）是个筐**](#2> 列表（list）是个筐)
    • [3> 列表里的元素是如何编号的？](#3> 列表里的元素是如何编号的？)
    • [4> 索引体系](#4> 索引体系)
    • [5> 如何取列表中的部分元素？](#5> 如何取列表中的部分元素？)
    • [6> 列表常用运算](#6> 列表常用运算)
    • • 1.增加
      • 2.删除
      • 3.修改
      • • 4.利用切片添加元素
      • 5.如何取列表中元素的最大/小值
      • 6.列表元素排序
      • 7.列表的遍历
      • [8.枚举函数 enumerate](#8.枚举函数 enumerate)
      • 9.用列表取代复杂分支结构
      • 列表元素个数
  • [2.7 元组(tuple)](#2.7 元组(tuple))
  • • [1> 列表 和 元组 可以互相嵌套](#1> 列表 和 元组 可以互相嵌套)
    • [2> 访问元组](#2> 访问元组)
    • [3> 元组的遍历](#3> 元组的遍历)
    • [4> 元组的内置函数](#4> 元组的内置函数)
    • [5> Python 输入列表方法](#5> Python 输入列表方法)
  • [2.8 字典](#2.8 字典)
  • • [1> 基本概念](#1> 基本概念)
    • [2> 字典的特点](#2> 字典的特点)
    • [3> 创建字典的方式](#3> 创建字典的方式)
    • • **直接创建字典**
      • [**可以使用 dict() 函数来创建字典**](#可以使用 dict() 函数来创建字典)
      • **添加字典**
      • [**用列表动态生成字典：zip() 函数**](#用列表动态生成字典：zip() 函数)
      • 字典合并（更新）
      • dict.clear()
    • [4> 删除字典里的元素](#4> 删除字典里的元素)
  • [2.9 集合](#2.9 集合)
  • • [1> 集合的创建](#1> 集合的创建)
    • [2> 集合元素的特征](#2> 集合元素的特征)
    • [3> 集合元素的操作](#3> 集合元素的操作)
    • • 遍历查看集合元素
    • [4> 集合常用函数](#4> 集合常用函数)
    • • [**最常见括号 ()、[]、{} 的区别**](#最常见括号 ()、[]、{} 的区别)
• 三、面向对象
• • [3.1 面向对象](#3.1 面向对象)
  • • [1） 字符串的查找与替换](#1） 字符串的查找与替换)
    • • [1> 字符串查找](#1> 字符串查找)
      • [2> 字符串替换](#2> 字符串替换)
      • [3> 字符串长度运算](#3> 字符串长度运算)
      • [4> 字符串转换大小写](#4> 字符串转换大小写)
      • [5> join()函数的使用方法](#5> join()函数的使用方法)
      • [6> strip()函数的使用方法](#6> strip()函数的使用方法)
  • [3.2. 列表的应用实例](#3.2. 列表的应用实例)
  • • 1）列表二维结构
    • 2) split() 方法 split() 方法)
    • 3) list.count() 方法(可以用于字符串) list.count() 方法(可以用于字符串))
    • 4) random 模块 random 模块)
    • 5) [] 操作符 [] 操作符)
• 总结

前言

在上一篇博客中，笔者介绍了Python的入门方法，这篇博客讲详细介绍Python的第一块知识------数据类型 。

数据类型对于一门语言来说十分重要，它决定了如何去使用数据，学习完这部分后，你将对Python的理解更进一层，并且可以简单的使用Python进行编程了。

一、变量

1.1.如何使用变量

C 语言规定，在使用变量之前，必须要先定义。python 语言在使用变量时不需要事先定义（声明），但每个变量在使用前都必须赋值。

变量赋值以后该变量才会被创建。等号（=）代表赋值。用来给变量赋值

​ 变量名 = 变量值

变量就是变量，它没有类型，所说的"类型"是变量所指的内存中对象的类型：

​ x = 4, y = 8.2, z = x + y, s = 'abc'

x、y、z 、s 这四个字母就被称为变量。

在程序语言中，与变量有关的还有两个概念：

• 名字（name）

• 类型（type）

1.2.如何定义变量的名字（标识符）

变量命名原则：

• 首字符是字母或下划线
• 其余可以是字母、下划线、数字
• 大小写敏感（A 和 a 是不同的变量名）
• 标识符不能是关键字

注意：虽然 Python 的变量名可以使用 _(下划线) 开头，但一般不建议使用，因为下划线开头的变量通常是 Python 系统自带的变量。

两种流行的变量（或函数）命名法则：

程序中变量（函数）命名在见名识义的基础上，也遵循一定的法则。

1. 骆驼命名法

   骆驼命名法分为小驼峰法和大驼峰法：

   小驼峰法：第一个单词以小写字母开始；第二个单词的首字母大写

    firstName

   大驼峰法：相比小驼峰法，大驼峰法把第一个单词的首字母也大写了

    FirstName

2. 下划线法

   变量或函数名中的每一个逻辑断点都有一个下划线来标记

printEmployeePaychecks()

print_employee_paychecks()

二、数据类型

2.1 整型数据

通常被称为整型或整数（int,integer），是正或负整数，不带小数点

a = 100 或 b = -100

Python 对整型是没有限制大小的，但实际上由于机器内存的有限，使用的整数是不可能无限大的

Python中的整数不仅可以用 十进制 表示，也可以用八进制 、十六进制 和 二进制 表示:

• 当用八进制表示整数时，数值前面要加上一个前缀"0o"
• 当用十六进制表示整数时，数字前面要加上前缀 0X 或 0x
• 当用二进制表示整数时，数字前面要加上前缀 0b

>>> 0o100                                       >>> 0b10
64												2
>>> 0x10										>>> 0b11000
16												24

2.2 浮点型数据

浮点型（float）数据就是数学中的实数
a = 2.3 a = 2.3 a=2.3

也可以类似科学计数法表示
a = 10.23 e 3 , b = 10 e − 5 a = 10.23e3 ,b = 10e-5 a=10.23e3,b=10e−5

e3 代表 1 0 3 10^3 103 ，e-5 代表 1 0 − 5 10^−5 10−5

2.3 布尔型（bool）数据

一个逻辑表达式，其实最终是代表了一个 bool 类型的结果。

布尔型实际上是整型的一个子类，仅有两个值。

本质上是用整型的 0 和 1 来存储， 0 代表 False， 1 代表 True。

2.4 复数型数据

实数 + 虚数 就是复数

虚数部分必须有j

2.5 字符串类型

字符串定义

字符串（String）是一个字符的序列。

使用成对的单引号、双引号或三引号括起来:

one_str = 'hello world'

​ two_str = "hello world"

​ three_str = '''hello world'''

单引号和双引号的使用方法是一样的，它们允许用户在同一行 内输入字符；而三引号允许用户在输入时进行换行。

既然双引号和单引号的使用方法一样，为什么要设置两种引号呢？

比如要输出内容：I'm a student

'I'm a student'，程序会报错。因为计算机是成对的识别引号

'I' 是一个字符串，而后面的 m a student' 就不认识了

在这种情境下，可以对整个字符串使用双引号，即：

​ "I'm a student"

输出：He said: "yes,I do"

在这种情境下，可以对整个字符串使用单引号，即：

​ 'He said:"yes,I do" '

总结：当需要表达的字符串中有单引号时，需要用双引号来包装字符串；当需要表达的字符串中有双引号时，要用单引号来包装字符串。

之所以有这些规则，是为了避免计算机理解代码时产生歧义。

为了解决这种歧义，Python引进了转义字符 \ 。也就是说，当某些字符（比如单引号）可能会产生歧义的时候，在它的前面加上转义符号\。

>>> print('I\'m a student')
I'm a student

转义字符还能解决换行的问题，Python中的换行符可以使用 \n 来表达，这样就很少会用到三引号来表达字符串了。

>>> print ('我们的未来在希望的田野上，\n人们在明媚的阳光下生活。')

我们的未来在希望的田野上
人们在明媚的阳光下生活。

为了彻底解决单引号双引号和转义字符的问题，可以采用三引号。

从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。

字符串打印四种情况：

• 字符串连接
• 单双引号转义
• 换行
• 三引号跨行字符串

例：

print('''I'm going to the movies''')

html = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
print(html)

基本的字符串运算

所谓的运算，数学定义的含义就是将数字之间进行各种计算，例如加减乘除。那么字符串是如何运算呢？

是否也可以将字符串进行所谓的"加减乘除"

1 > 字符串相加（合并）（+）

s1 = 'Hello '
s2 = 'CAU'
s = s1 + s2

通过加法可以将两个字符串进行合并

2> 字符串相乘（重复）（*）

s1 = 'CAU'
s = s1*3

通过乘法可以实现对字符串的重叠复制

3> 字符串相减（-）

s1 = 'Hello '
s2 = 'CAU'
s = s1 - s2

字符串对应的减法 和除法，在 Python 中是错误的.

4> 成员运算符（in）

判断一个字符串是否是另一个字符串的子串

>>> name = 'zhang san'
>>> 'an' in name
True

>>> name = 'zhang san'
>>> 'sn' in name
False

5> 字符串切片

在 Python中，切片(slice)是对序列型对象(如 string、list、tuple)的一种高级索引方法

6> 用 字符串名[索引号] 索引字符串中的单个元素

通过下标索引可以取出字符串序列中一个对应的元素。索引下标从 0 开始，依次为 0,1,2,3...

>>> s = 'abcdefghijk'
>>> s[5]
f
>>> s[0]
a

7> 字符串切片模式

（1）字符串切片 模式1：[start:end]

从字符串中切出相应的元素，前闭后开。也就是不包括 end 那个元素。即切片中元素的索引从 start 到 end - 1

>>> s = 'abcdefghijk'
>>> s[1:4]
bcd
>>> s[1:]
bcdefghijk
>>> s[:]
abcdefghijk

（2）字符串切片 模式2：[start🔚step]

带步长的切片，而且步长有方向，可正可负;这也是最一般的切片模式，模式1 是省略了 步长为1 的情况。

>>> s = '123456789'
>>> s[4:8:2]
57

（3）字符串逆序排列

字符串索引体系

>>> s = 'abcdefg'
>>> s[3:-1]
def
>>> s[0:-1]
abcdef
>>> s[2:-2]
cde

>>> s = '123456789'
>>> s[4:0:-1]
5432
>>> s[-2::-2]
8642

8> 字符串和数的转换

• int(x) : 把字符串转换成整数

• float(x) : 把字符串 x 转换成小数

• str(x) : 把 x 转换成字符串

• eval(x) : 把字符串 x 看作一个 python 表达式，求其值

  x = 5
  eval ('x+3')

9> 字符串也可以使用部分列表的成员函数

例如：str.count 用于计算字符串中某个字符出现的频率

>>>list_in = input()
>>> list_out = []
>>> for lis in list_in:
>>>    if list_in.count(lis) == 1:
>>>         list_out += lis
>>> list_out.sort()     
>>> print(list_out)

2.6列表(list)

列表 （list），是python中最有用的数据结构之一，它可以同时保存一个以上的值。也就是说能够在 单独 的变量名中存储一个或多个值。

list 里面按顺序排好了一堆数据：

1> Python 里的列表形式：

​ alist = [1, 2.4,'one',10]

用一个变量 来表示，以便程序调用它，列表里的数据类型可以多种多样，支持混搭 ！列表里每个元素之间，全用逗号隔开。

2> 列表（list）是个筐

3> 列表里的元素是如何编号的？

​ alist = [1, 2.3, "three", 4]

从 0 开始计数，和字符串一样，列表里的元素，索引号也是从 0 开始

alist = [1,2,3.4,'a']
print(alist[2])

4> 索引体系

5> 如何取列表中的部分元素？

通过 切片 来取列表中的一部分元素

>>> alist = [1,2,3.4,'a']
>>> print(alist[1:3])
[2, 3.4]
>>> print(alist[2:4])
[3.4, 'a']
>>> print(alist[0:4])
[1, 2, 3.4, 'a']

6> 列表常用运算

1.增加

python中关于增加 list 中的某个元素，一般有哪些方法呢？

>>> s = ['a','b','d','e']
>>> s.insert(2,'c')
>>> print(s)
['a', 'b', 'c', 'd', 'e']

在结果里看到，新添的词 C 被放在第三个位置（下标为 2 ），而原来位置上的 D 被往后推了一个格。

注意：调用函数一般是圆括号()

如果想在最后位置上添加一个元素，可以用 append 函数：

>>> s = ['a','b','d','e']
>>> s.append(2)
>>> print(s)
['a', 'b', 'c', 'd', 2]

如果想在尾部位置上添加 n 个元素，可以用 extend 函数:

>>> s = ['a','b','d','e']
>>> s.extend([1,2,3])
>>> print(s)
['a', 'b', 'c', 'd', 1, 2, 3]

• append 方法只能在尾部加入
• insert 方法可在任意位置加入
• extend 方法则可以在尾部一次性加入多个元素

list添加单个字符时用法和字符串一样可以+=

>>> lis = []
>>> lis += 'a'
['a']
>>> lis += 'abcd'
['a', 'a', 'b', 'c', 'd']

2.删除

Python 中关于删除 list 中的某个元素，一般有三种方法:

• remove ：删除单个元素，删除首个符合条件的元素，按值删除
• pop：根据索引删除
• del：根据索引来删除

>>> s = [1,2,3,'a']
>>> s.remove(2)
>>> print(s)
[1, 3, 'a']
>>> s = [1,2,3,'a']
>>> s.pop(3)
>>> print(s)
[1, 2, 3]

Python 中的 del 用法比较特殊，del 是 python 关键字，就像 def、and、or 一样。它不是字典、列表的方法，但是可以用来删除字典、列表的元素。

>>> s = [1,2,3,'a']
>>> del s[3]
>>> print(s)
[1, 2, 3]

3.修改

>>> s = ['a','b','d','e']
>>> s [3] = 12
>>> print(s)
['a', 'b', 'd', 12]

列表的大小和内容可以随意改变，在插入、删除、修改列表元素时，不需要建立一份新的列表拷贝，而是在原来的内存地址上直接修改列表对象。这个叫"本地可修改"

因为插入是本地修改 ，而不是返回修改后的新列表，insert 方法的返回值是 None ！

4.利用切片添加元素

5.如何取列表中元素的最大/小值

max() 方法返回给定参数的最大值，参数可以为序列

max('23689')
max([2,3,6,8])

6.列表元素排序

sorted() 作为 Python 内置函数之一，其功能是对序列（列表、元组、字典、集合、还包括字符串）进行排序。sorted() 函数的基本语法格式如下：

​ list = sorted(iterable, key=None, reverse=False)

• iterable：指定要排序的序列
• key：可以自定义排序规则，缺省值是 None
• Nonereverse：True 为倒序排列，False 为正序排列

sorted() 函数返回一个排序好的新列表，原列表不变

>>> x = [4, 6, 2, 10, 7, 9]
>>> y = sorted(x) 
>>> print (y)
[2, 4, 6, 7, 9, 10]

另外，列表还有自己的 sort 方法，其对原列表进行排序

>>> x = [4, 6, 2, 10, 7, 9]
>>> x.sort() 
>>> print (x)
[2, 4, 6, 7, 9, 10]

7.列表的遍历

使用 for 循环遍历列表：

lis = [5,6,7,8,9,10]
for i in lis:
    print (i)

使用 while 循环遍历列表

lis = [5,6,7,8,9,10]
L = len (lis)
i = 0
while i < L:
    print (lis[i])
    i = i + 1

8.枚举函数 enumerate

包含每次迭代的计数（从默认为 0 开始）和迭代序列获得的值

>>> friends = ['zhang', 'wang', 'zhao', 'li']
>>> for i in friends:
>>>    print(i)
zhang
wang
zhao
li
>>> friends = ['zhang', 'wang', 'zhao', 'li']
>>> for i,j in enumerate(friends):
>>> 	print(i,j)
0 zhang
1 wang
2 zhao
3 li

9.用列表取代复杂分支结构

例：输入 1-7，输出对应的是英文星期几；如果输出超出1-7范围的数，输出illegal

weekdays = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"]
n = int(input())
if n > 7 or n < 1:
    print("Illegal")
else:
    print(weekdays[n-1])

列表元素个数

len()

# 创建一个示例列表
my_list = [1, 2, 3, 4, 5]

# 使用 len() 函数获取列表元素的个数
num_elements = len(my_list)

# 打印结果
print("列表中的元素个数是:", num_elements)

2.7 元组(tuple)

元组（tuple），是python中的另一种特色的数据类型。元组 和 列表 是相似的，可以存储不同类型的数据。

但是，元组是不可改变的，创建后就不能做任何修改操作了，元组里元素的调用是通过圆括号()+索引的形式。

列表 和 元组 的区别：

• 元组用括号()定义，列表用方括号[]定义

• 元组不可更改

1> 列表 和 元组 可以互相嵌套

上面的元组里包含了列表，元组允许嵌套【俄罗斯套娃】

同理，列表里也包含了元组，所以列表也允许嵌套。

有一点要注意，当元组里面只有一个元素的时候，一定要加 ,

比如 (100,):

2> 访问元组

3> 元组的遍历

tup = (5,6,7,8,9,10)
for i in tup:
    print (i)

4> 元组的内置函数

列表有自己的 sort 方法，可对原列表进行排序。那么元组是否也有类似的排序方法呢？

​ 没有！

5> Python 输入列表方法

>>> lis = eval(input())
>>> print (lis)
(1, 2, 3, 4, 5)
>>> type(lis)
<class 'tuple'>

>>> lis = eval(input())
>>> lis = list (lis)
>>> print (lis)
1, 2, 3, 4, 5
>>> type(lis)
<class 'list'>

2.8 字典

字典：字典是 python 内置的最重要的数据结构之一。字典如其名所示，可以建立对象之间的映射关系。其格式为：关键字:值

在字典中，任何一个元素都有一个关键字 key 和值 value，元素在字典中没有序号，即没有任何顺序（和列表、元组不同）。同时，每个 key 必须是唯一的。

1> 基本概念

由于键 key 值不是序号值，所以无法使用列表类型进行有效存储和索引

​ { '大头儿子':6,'小头爸爸':35,'隔壁老王':37 }

用 { } 来表示，按照 key:value 来表示字典中的元素，其中 key 是键，value 是值， key:value 就是 键值对

列表、集合、字典 等可变的数据类型，不可作为字典元素的键。

2> 字典的特点

（1）键 key 必须是不可变 的，且不重复值 ， value 可以是任意对象

（2）key 唯一！

字典最主要的用法是查找与特定键相对应的值，可通过引用 key 来实现！这是和列表、元组最大的不同。

字典通过一对对的键和值来反映一种映射关系

在 python 3.5 及以前，字典元素顺序不确定。在 python 3.6 及以后，顺序同元素加入字典的顺序。

字典中,如果想通过 key 值获取对应的 value 值， 访问模式采用 dic[key] 格式

>>> contry = {'中国': '北京', '美国': '华盛顿','俄罗斯':'莫斯科','法国':'巴黎'}
>>> print (contry['俄罗斯'])
莫斯科

3> 创建字典的方式

直接创建字典

用 大"{ }"括号 来表示

>>> {'中国农业大学':'清华东路','北京大学':'中关村','北师大':'北太平庄'}
#空字典
>>> dic = {}
>>> type(dic)
<class 'dict'>

可以使用 dict() 函数来创建字典

列表 、元组 都可以使用 dict() 函数来创建字典

lis = [3,4,2,7]
d = dict (lis)

dict() 函数可以返回一个空的字典

>>> lis = [[3,1],[4,2],[7,5]]
>>> d = dict (lis)
>>> print (d)
{'3': 1, '4': 2, '7': 5}

列表创建字典一定要符合 key:value 原则

添加字典

>>> d = {}
>>> d['name'] = '张三'
>>> d['job'] = 'Teacher'
>>> d['age'] = 32
>>> print(d)
{'name': '张三', 'jod': 'Teacher', 'age': 32}

只要元素和元素之间存在对应关系，就可以通过 dict() 函数把它们转换成相应的 key 和 value，生成一个一个的映射关系，也就是 键值对

>>> info = [['张三',97],['李四',73],['王五',82]]
>>> binfo = dict (info)
>>> print (binfo)
{'张三': 97, '李四': 73, '王五': 82}

用列表动态生成字典：zip() 函数

已知有姓名列表和分数列表，如何生成字典类型的学生成绩信息表？

​ 将两个列表对应的元素分别组合起来，可以通过 python 的内置函数 zip() 完成, 通过 zip() 函数，把两个列表中的数据对应打包。

zip() 函数在生成字典的过程当中常常会用到：

>>> names = ['张三','李四','王五']
>>> grades = [89,75,90]
>>> ng = dict(zip(names,grades))
>>> print(ng)

如何分别遍历字典中的 key 和 value

与 列表、元组 类型一样，字典可以通过 for-in 语句对其元素进行遍历

>>> info = {'张三': 97, '李四': 73, '王五': 82}
>>> for i in info.keys():
>>>    print(i)
张三
李四
王五
>>> info = {'张三': 97, '李四': 73, '王五': 82}
>>> for i in info.values():
>>>    print(i)
97
73
82

遍历字典的所有键值对

通过 items() 方法来处理

>>> info = {'张三': 97, '李四': 73, '王五': 82}
>>> for i,j in info.items():
>>>        print(i,j)
张三 97
李四 73
王五 82

用 get 获取字典中的值

关于获取字典中的值，一种简单的方式就是用字典方法：get()

调用语法：dictionary.get(keyname, value)

>>> info = {'张三': 92, '李四': 83, '王五': 62}
>>> print (info.get('李四'))
83

查看 keys 和 values 值

• 全部的 keys

>>> info = {'张三': 92, '李四': 83, '王五': 62}
>>> print (info.keys())
dict_keys(['张三', '李四', '王五'])

• 全部的 value

>>> info = {'张三': 92, '李四': 83, '王五': 62}
>>> print (info.values())
dict_values([92, 83, 62])

字典合并（更新）

有两份成绩单：第一份是原有信息，第二份是成绩更改人员和新插班学生的成绩，如何获得修改后的完整成绩单？

>>> info1 = {'张三': 92, '李四': 83, '王五': 62}
>>> info2 = {'李四': 86, '赵六': 83, '钱七': 90}
>>> info1.update(info2)
>>> print (info1)
{'张三': 92, '李四': 86, '王五': 62, '赵六': 83, '钱七'：90}

dict.clear()

clear() 用于清空字典中所有元素（键-值对），对一个字典执行 clear() 方法之后，该字典就会变成一个空字典

list1 = ['Author', 'age', 'gender']
list2 = ['张三', 38, '男']
d = dict(zip(list1, list2))
print(d)
d.clear()

列表中存放多个字典

>>> phone_book = [{'name':'张三', 
>>>                'Tel':'1350123'},
>>>               {'name':'李四', 
>>>                'Tel':'1365123'},
>>>               {'name':'王五', 
>>>                'Tel':'6273666'}
>>>              ]
>>> for i in phone_book:
>>>     print (i)
{'name': '张三', 'Tel': '1350123'}
{'name': '李四', 'Tel': '1365123'}
{'name': '王五', 'Tel': '6273666'}

例题：读取一串字符（可以包括数字等），计算每个字母出现的个数

# 输入：abadfba121   输出：a:3,  b:2,  d:1,  f:1,  1:2,  2:1
# 做法1：
str = input()
dic = {}
for s in str:
    if (s in dic):
        dic [s] = dic [s] +1    
    else:
        dic [s] = 1
print (dic)
# 做法2：
str = input()
dic = {}
for s in str:
    dic[s] = dic.get(s,0)+ 1
print (dic)
#get 既避免了 key 不存在导致的错误，又可以提供默认值（0）

4> 删除字典里的元素

dt = {'zhangsan':18,'李四':19,128:10,(1,2):[4,5]}
del dt['李四'] 
print(dt)

2.9 集合

集合（简称集）是数学中一个基本概念。以某种方式给定的一些事物的全体称为一个集合。集合中的成员称为这个集的元素

在Python中，集合是一个无序集合，没有重复元素。基本用途包括成员测试和消除重复的条目，还支持数学运算，如并集、交集、差集和对等差分。

1> 集合的创建

有两种方法可以创建一个集合：一个是用内置函数 set() 创建集合（括号内为可迭代数据类型），另一个是使用花括号 {}。

>>> s = set([1, 2, 3])
>>> print(s)
{1, 2, 3}
>>> s = {3,4,5}
>>> print(s)
{1, 2, 3}

在 Python 中，集合由内置的 set 类型定义:

要创建集合，需要将所有项（元素）放在花括号 {} 内，以逗号 , 分隔

s = {'p','y','t','h','o','n'}

用 set() 函数创建集合。括号内为可迭代数据类型

>>> s = set ('adad')
{'a', 'd'}
>>> s = set ([1,2,3])
{1, 2, 3}

集合可以有任意数量的元素，它们可以是不同的类型（如：数字、元组、字符串等）。但是，集合不能有可变元素**（列表、集合或字典）**

在 Python 中，空花括号（{}）用于创建空字典

如何创建一个没有任何元素的 空集合 呢？

使用 set() 函数（不要包含任何参数）

2> 集合元素的特征

集合中的元素有三个特征：

• 确定性

  集合中的元素必须是确定的，{3,4,5}是一个集合

• 互异性

  集合中的元素互不相同，{3,4,5,5}就不是一个集合

  利用 互异性 性质，可以进行列表元素查重

• 无序性

  集合中的元素没有先后之分，{3,4,5}和{3,5,4}算作同一个集合

3> 集合元素的操作

遍历查看集合元素

>>> s = set ('python')
>>> for i in s:
>>>    print(i)
p
y
t
h
o
n

集合支持一系列标准操作，包括并集、交集、差集 和 对称差集

假设 a、b 分别是两个集合

c = a | b # a 和 b 的并集（返回一个新集合，包括集合 a 和 b 中的所有元素）

d = a & b # a 和 b 的交集（返回一个新集合，包括同时在集合 a 和 b 中的元素）

e = a -- b # 求差集（返回一个新集合，包括在集合 a 中但不在 b 中的元素）

f = a ^ b # 对称差集（元素在 a 或 b 中，但不会同时出现在二者中）

s.union(t) （s | t） 返回一个新的 set 包含 s 和 t 中的每一个元素 并集

s.intersection(t) （s & t） 返回一个新的 set 包含 s 和 t 中的公共元素 交集

s.difference(t) （s - t） 返回一个新的 set 包含 s 中有但是 t 中没有的元素 差集

s.symmetric_difference(t) （s ^ t） 返回一个新的 set 包含 s 和 t 中不重复的元素 对称差集

4> 集合常用函数

• add(x)： 添加元素 x。如果 x 已经存在，则不添加
• clear()： 清空集合
• remove(x) 删除元素 x。如果不存在元素 x，则引发异常
• update(x) 将序列 x 中的元素加入到集合

列表（元组）里元素去重

>>> lis = ['CAU','BUAA','PKU','BNU','CAU']
>>> s = set(lis)
>>> print(s)
{'CAU', 'PKU', 'BUAA', 'BNU'}
>>> a = [11,34,11,22,25,34]
>>> s = set(a)
>>> print(s)
{11, 34, 22, 25, 34}

最常见括号 ()、[]、{} 的区别

目前为止，已经在列表、元组、字典和集合中用到了三种类型的括号：

()、[]、{} ，这三类括号如何使用呢？

• 小括号()

  • 函数调用

  • 元组创建

  • 表达式优先级分组

  # 函数调用
  length = len('hello')
  # 元组创建
  tup = (1,2,3,4)
  # 表达式优先级分组
  x = (2+3)*4

• 方括号[]

  • 列表(list)的创建

  • 访问元素

  • 用于切片操作

    # 创建列表
    my_list = [1,3,5]
    # 访问元素
    second_element = my_list[1]
    # 切片操作
    sub_list = my_list[0:2]

• 花括号{}

  • 字典(Dictionary)的创建

  • 集合(Set)的创建

  • 用于格式化字符串(f-string)

    # 字典创建
    my_dict = {'name':'zhang san', 'age':20}
    # 集合创建
    my_set = {1,2,3}
    # 格式化字符串
    greeting = f'Hello, {my_dict["name"]}!'  
    print(greeting)

三、面向对象

3.1 面向对象

面向对象编程（Object-Oriented Programming，OOP）是一种基于对象（Object）的编程范式。

类是对一类事物的概括，类里的每一事物或每个单独的个体就是对象。

对象（实体），包含 属性 和 方法 两部分：

• 属性：是对象的特征

• 方法(函数）：是对象能够完成的操作

假设对象是 O，则 O.a 表示对象 O 的属性 a （attribute），O.m() 表示对象 O 的操作 ，m -- method.

比如红旗轿车是对象，用 C 来表示。汽车颜色是对象属性，用 C.color 表示；行进是汽车的一个动作，m（method）可以表示为：

C.move()

在python中，字符串、列表、元组等数据类型，都是当作对象看待。

字符串的三种方法：

• 查找字符串
• 转换字符串
• 解析字符串

1） 字符串的查找与替换

Python 文本处理的常用工具-------字符串的 查找 与 替换

1> 字符串查找

字符串的 find 方法实现子字符串查找的操作，如果包含待查找的子字符串就返回它的索引值，如果没有找到，就返回 -1

>>> s = 'abcdefgh'
>>> s1 = s.find ('efg')
>>> print (s1)
4

2> 字符串替换

字符串的 replace 方法实现子字符串替换的操作

>>> s = 'abcdefgh'
>>> s = s.replace ('abcd','xyz')
>>> print (s)
xyzefgh

3> 字符串长度运算

如何计算一个字符串的长度？ 采用 len() 函数

>>> s = 'hello world'
>>> print (len(s))
11

4> 字符串转换大小写

upper()：将字符串中的小写字母转为大写字母

lower()：将字符串中的大写字母转为小写字母

s = 'sadasadf'
s.upper()

s = 'ASDEFR'
s.lower()

5> join()函数的使用方法

join()：函数通常用于将序列（字符串、元组、列表、字典等）中的元素以指定的字符连接生成一个新的字符串

语法：'sep'.join(seq)

• sep：分隔符，可以为空

• seq：要连接的元素序列、字符串、元组、字典

>>> s = 'abcdef'
>>> s = '-'.join(s)
a-b-c-d-e-f

>>> s = ['www','baidu','com']
>>> url = '.'.join(s)
www.baidu.com

isdigit 方法只能判断正整数。

6> strip()函数的使用方法

strip()：可以删除字符串的某些字符，其语法如下（其中：s 为字符串，rm 为要删除的字符序列）:

• s.strip(rm)： 删除s字符串中开头、结尾处，位于 rm删除序列的字符
• s.lstrip(rm) ：删除s字符串中开头处，位于 rm删除序列的字符 (left)
• s.rstrip(rm) ：删除s字符串中结尾处，位于 rm删除序列的字符 (right)

注意：当 rm 为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，这里的 rm 删除序列是只要边（开头或结尾）上的字符在删除序列内，就删除掉。

>>> s = '  Hello world   '
>>> print(s.strip())
Hello world

>>> s = '123abc'
>>> s1 = s.strip('12')
3abc

3.2. 列表的应用实例

1）列表二维结构

# 列表一维结构
lis = ['cau',12,15.3,(4,9),25,'python',3,14159]
# 列表二维结构
>>> table = [[1,2,3],[4,5,6],[7,8,9],[10,11,12],[13,14,15]]
>>> table[0][2]
3
>>> table[3][1]
11
>>> table[1][1]
5

列表一维结构：

列表二维结构：

2) split() 方法

split() ：通过指定分隔符对字符串进行切片。分隔符将字符串分隔成多个字符串（存储到列表中），如果不指定分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。

>>> s = 'to be or not to be'
>>> s1 = s.split()
>>> print (s1)
['welcome', 'to', 'china']

split() 经常和 input() 联合使用，用于接收多个用户输入

s = input().split()
s = input().split(',')

3) list.count() 方法(可以用于字符串)

list.count() ：列表对象一个用于统计某个元素在列表中出现的次数的方法

这里list也使用了+=1

>>> L = [123, 'xyz', 'cau', 123]
>>> c = L.count(123)
>>> print(c)
2
>>>list_in = input()
>>> list_out = []
>>> for lis in list_in:
>>>    if list_in.count(lis) == 1:
>>>         list_out += lis
>>> list_out.sort()     
>>> print(list_out)

4) random 模块

Python 中有一个内置的 random 模块，可用于生成随机数

函数	含义
seed(x)	给随机数一个种子值，默认为系统时钟
random()	生成一个[0, 1.0)之间的随机小数
uniform(a,b)	生成一个a到b之间的随机小数
randint(a,b)	生成一个a到b之间的随机整数
randrange(a,b,c)	随机生成一个从a开始到b以c递增的数
choice()	从序列（例如：列表）中随机返回一个元素
shuffle()	将一个列表中元素随机打乱
sample(, k)	从指定序列中随机获取k个元素

5) [] 操作符

\] 可以作为条件操作符，语法：`[ expression condition]` **如果满足条件，则执行expression**。 ```python import numpy as np # 创建一个形状为(100,)的一维数组 arr = np.arange(100) # 使用np.arange生成一个从0到99的整数数组 # 分割数组 # 我们可以使用列表推导式结合切片来生成子数组 subarrays = [arr[i:i+10] for i in range(0, 100, 10)] # 输出结果以验证 for i, subarray in enumerate(subarrays): print(f"Subarray {i+1}: {subarray}") ``` ## 总结  Python的数据类型构成了其灵活而强大的基础，允许开发者以直观和高效的方式处理各种数据。这些类型不仅支持基本的数值和文本操作，还提供了复杂的数据结构来管理集合、序列和映射，使得Python成为了一种适用于多种编程任务的语言。通过这些丰富的数据类型，Python使得数据操作变得简洁而强大，无论是在科学计算、数据分析还是日常脚本编写中都能发挥重要作用。