大三寒假复习Python笔记系列（二）

大三寒假复习Python笔记系列（二）

---

前言

本文从Python list，Python tupple，Python的类与对象进行学习

---

提示：以下是本篇文章正文内容

一、Python List

Python 中的数据结构是通过某种方式组织在一起的数据元素的集合，这些数据元素可以是数字、字符、甚至可以是其他数据结构 在 Python 中，最基本的数据结构是序列（列表和元组），序列中的每个元素都有一个序号（元素的具体位置），这个序号叫索引，索引下标从0开始，以此类推…

列表俗称是 Python 中的苦力，列表可变（可以改变列表的内容）

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['baidu', 'google', 12, 34];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

1.列表函数

1.1 list 函数
如果对字符串赋值后想要改变字符串中的某个值，因为字符串不能像列表一样可更改，如果想改变这时候可以利用 list 函数，如下：

>>> ll=list('hello')
>>> ll
['h', 'e', 'l', 'l', 'o']
>>> ll[2]
'l'
>>> ll[2]='5'
>>> ll
['h', 'e', '5', 'l', 'o']

1.2 len 函数
len 函数返回列表中的元素个数

>>> list1 = ['baidu', 'google', 12, 23];
>>> len(list1)
4```

1.3 max 函数
max 函数返回列表元素最大值

>>> list_num=[2,3,5,6,8,12]
>>> max(list_num)
12

1.4 min 函数
返回列表元素最小值

>>> list_num=[2,3,5,6,8,12]
>>> min(list_num)
2

2.列表方法

列表提供了几个详细的方法，这些方法用于检查或者修改列表中的内容
append、count、extend、index、insert、pop、remove、sort、clear、copy

3.列表基本操作

列表可以使用所有适用于序列的标准操作，比如第7天所学的索引、分片、连接和相乘，更有趣的是，列表是可以修改的，也就是定义的列表内容可以根据需求更改，本节介绍一些改变列表的方法：如元素赋值、元素删除、分片赋值以及列表方法（但是请注意，并不是所有的列表方法都能真正改变列表）

3.1改变列表：元素赋值
在列表中要给指定的元素赋值时，我们需要指定特定的索引标记来为列表中某个特定的，位置明确的元素赋值，比如 x[3]=5

# 
x=[1,2,3,4,5]
x
[1, 2, 3, 4, 5]
# 改变列表第四个元素的内容
x[3]=5
x
[1, 2, 3, 5, 5]

注意： 不能为一个位置不存在的元素赋值，如果列表长度为2，则不能为索引为10 的元素进行赋值，如果需要赋值则需要创建一个长度为11的列表。
3.2 删除列表元素
若要删除列表中的元素，直接利用del删除即可

# 定义长度为4的姓名列表
names=['zhangsan','lisi','wangwu','zhaoliu']
names
['zhangsan', 'lisi', 'wangwu', 'zhaoliu']

# 删除第三个元素
del names[2]

# 最后列表长度由4变为3
names
['zhangsan', 'lisi', 'zhaoliu'

del 语句还能用于删除其他元素，也可以用于变量的删除操作。
3.3 分片赋值
在 Python 中对序列或者列表的分片操作是一个很强大的特性，分片赋值会显得更加强大，例如：

# 定义一个list
name = list('Pyther')

# 改变 list 中的最后两个值
name[4:]='on'
name
['P', 'y', 't', 'h', 'o', 'n']

从上可知，程序可以一次为多个元素赋值，在分片赋值时，可以使用与原序列不等长的序列将分片替换，例如：

name_re = list('perl')
name_re
['p', 'e', 'r', 'l']
# 分片替换
name_re[1:] = list('ython')
name_re
['p', 'y', 't', 'h', 'o', 'n']

分片赋值还可以在不需要更改原有列表任何内容的情况下进行新元素插入

num = [1,4,5]
# 在第一个元素后插入新的元素
num[1:1]=[2,3]
num
[1, 2, 3, 4, 5]

同理也可以通过分片操作来删除列表中的元素，同样也支持负数分片操作

num
[1, 2, 3, 4, 5]
# 给第一个和迪桑元素之间分片赋值一个空序列，即删除元素
num[1:3] = []
num
[1, 4, 5]

# 负数分片操作
num[-1:-1] = [5,5,5]
num
[1, 2, 3, 4, 5, 5, 5, 5, 6]

二、Python tupple

Python 中的数据结构是通过某种方式组织在一起的数据元素的集合，这些数据元素可以是数字、字符、甚至可以是其他数据结构 在 Python 中，最基本的数据结构是序列（列表和元组），序列中的每个元素都有一个序号（元素的具体位置），这个序号叫索引，索引下标从0开始，以此类推…

1.Python 的元组与列表类似，不同之处在于元组的元素不能修改。

2.元组使用小括号()，列表使用方括号[]。

1.元组基本操作

1.1创建元祖
元组创建很简单，只需要在括号中添加元素(不需要括号也可以)，并使用逗号隔开即可。

>>> tup1 = ('baidu', 'google', 12, 34); 
>>> tup2 = (1, 2, 3, 4, 5 );
>>> tup3 = "a", "b", "c", "d";

# 创建空元组
>>> tup4 = ()

# 查看tup4和tup3的类型
>>> type(tup4)
<class 'tuple'>
>>> type(tup3)
<class 'tuple'>

注意： 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用，如下：

>> TupNum = (34)   
>>> type(TupNum)   # 不加逗号是整型
<class 'int'>
>>> TupNum = (34,)
>>> type(TupNum)  # 加上逗号变元组
<class 'tuple'>

元组与字符串类似，下标索引从 0 开始，可以对元组进行截取，组合等操作。
1.2 访问元组
元组的访问和序列访问元素一样，都是通过下标索引进行访问操作

>>> tup1 = ('baidu', 'google',1,2)
>>> tup2 = (1, 2, 3, 4, 5, 6, 7)
>>> tup1[0:2]
('baidu', 'google')
>>> tup2[1:4]
(2, 3, 4)

1.3修改元组
元组中的值一旦定义就不能修改，但是我们可以通过元组与元组之间的连接关系来对元组进行修改，例如：

>>> tup1 = ('baidu', 'google',1,2)
>>> tup2 = (1, 2, 3, 4, 5, 6, 7)
>>> tup1 + tup2
('baidu', 'google', 1, 2, 1, 2, 3, 4, 5, 6, 7)

注意： 以下修改元组属于非法操作，因为元组不支持通过索引列来修改，只能对元组进行复制和连接操作

tup1[0] = 100 （不能进行此操作）
该处使用的url网络请求的数据。

1.4 删除元组
由于元组的不可修改性，所以元组中的元素值是不允许删除的，但我们可以使用 del 语句来删除整个元组，如下实例:

#!/usr/bin/python3
 
tup1 = ('baidu', 'google',1,2)
 
print (tup)
del tup;
print ("删除后的元组 tup : ")
print (tup)

# 报错信息如下，证明整个元组已经被删除
删除后的元组 tup1 : 
Traceback (most recent call last):
  File "tupple.py", line 29, in <module>
    print(tup1)
NameError: name 'tup1' is not defined

---

2.元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。总而言之对整个元组进行一些运算后就会生成一个新的元组。

3.元组内置函数

和列表一样，元组同样也拥有一些内置函数，这些函数用于判元组中的元素大小以及将元组做相应的转换

#计算元组元素个数。
len(tuple)

#返回元组中元素最大值。
max(tuple)

#返回元组中元素最小值。
	min(tuple)
	
#将列表转换为元组。
	tuple(seq)

三、Python 类与对象

在刚接触编程时，我们就了解到编程界有两大思想：面向过程与面向对象，Python 就是一门面向对象的语言，如果你了解过面向对象的思想，自然就知道面向对象思想包含两个基本概念：类与对象 ，下面我们就一起详细学习下 Python 的类与对象吧！

1 基本概念

1.1 面向对象
面向对象是一种抽象，是一种用分类的方式看待问题的方法，用 Java 的编程思想来说就是：万物皆对象；面向对象有三大特性：封装、继承、多态。

1.2 类
上面说了面向对象是一种用分类的方式看待问题的方法，一个分类就是一个类，可以把类看作是一个抽象的模板，如：Car 类。

1.3 对象
对象是根据类创建出来的一个个实例。

2 基本使用

2.1 类的定义

# 类的定义
class Car:
    pass

2.2 对象的创建

# 创建 Car 的实例对象 c
class Car:
    pass
	
c = Car()

3 类中的方法

3.1 内置方法
Python 创建任何一个类的时候，都会包含一些内置的方法，主要包括如下：

3.2 自定义方法
Python 有三种常见的方法，分别为：实例方法、类方法、静态方法，这三种方法都定义在类中。

3.2.1 类方法
类方法是将类本身作为对象进行操作的方法。

定义与使用

'''
类方法（可调类变量、可被实例调用、可被类调用）
1、类方法通过@classmethod装饰器实现，只能访问类变量，不能访问实例变量；
2、通过cls参数传递当前类对象，不需要实例化。
'''
class Car(object):
    name = 'BMW'
    def __init__(self, name):
        self.name = name
    @classmethod
    def run(cls,speed):
        print(cls.name,speed,'行驶')
# 访问方式1
c = Car("宝马")
c.run("100迈")
# 访问方式2
Car.run("100迈")

3.2.2 静态方法

静态方法是类中的函数，不需要实例。
定义与使用

'''
静态方法（可调类变量、可被实例调用、可被类调用）
1、用 @staticmethod 装饰的不带 self 参数的方法；
2、静态方法名义上归类管理，实际中在静态方法中无法访问类和实例中的任何属性；
3、调用时并不需要传递类或实例。
'''
class Car(object):
    name = 'BMW'
    def __init__(self, name):
        self.name = name
    @staticmethod
    def run(speed):
        print(Car.name,speed,'行驶')
		
# 访问方式1
c = Car("宝马")
c.run("100迈")
# 访问方式2
Car.run("100迈")

3.2.3 实例方法
实例方法就是类的实例能够使用的方法。

定义与使用

# 实例方法（可调类变量、可调实例变量、可被实例调用）
# 第一个参数强制为实例对象 self。
class Car(object):
    name = 'BMW'
    def __init__(self, name):
        self.name = name
    def run(self,speed):
        print(self.name,speed,'行驶')

# 访问
c = Car("宝马")
c.run("100迈")

4 类的继承

定义与使用

# 基本语法：class ClassName(BaseClassName)
# 父类
class Car(object):
    name = 'BMW'
    def __init__(self, name):
        self.name = name
    def run(self,speed):
        print(self.name,speed,'行驶')
        
# 子类
class BMWCar(Car):
    conf = "经济适用型"
    pass

# 调用父类 Car 中 run 方法
bc = BMWCar("BMW经济适用型轿车")
bc.run("100迈")

5 类的多态

定义与使用

# 父类
class Car(object):
    name = 'BMW'
    def __init__(self, name):
        self.name = name
    def run(self,speed):
        print('Car-->',self.name,speed,'行驶')

# 子类1
class BMWCar(Car):
    def run(self,speed):
        print('BMWCar-->',self.name,speed,'行驶')

# 子类2
class SVWCar(Car):
    def run(self,speed):
        print('SVWCar-->',self.name,speed,'行驶')

# 调用 run 方法
c = Car("Car")
c.run("120迈")

bc = BMWCar("宝马")
bc.run("100迈")

sc = SVWCar("大众")
sc.run("80迈")

# 输出结果
'''
Car--> Car 120迈 行驶
BMWCar--> 宝马 100迈 行驶
SVWCar--> 大众 80迈 行驶
'''

在上面的例子中，我们可以看出：c、bc 、sc 是不同类型的对象，在它们调用 run 方法时，调用的均是各自类中的方法，这就是多态。

总结

Python列表与Python元组给大家介绍了 Python 数据结构之元组的操作与使用，对 Python 工程师使用列表提供了支撑。 Python 类与对象的定义和使用，学习熟悉根据实际情况在项目中灵活使用不同类型的方法。