Python

Python基础

Python基础总结

Posted by 明心 on 2020-03-11

Python基础

1：环境安装

安装python编译环境，推荐pycharm或subline，pycharm专业版安装具体教程见压缩包

2：python的注释、缩进、输入及输出

这里通过第一个python程序来引出python输入、输出的方法

1
2
3
# 这是第一个python程序
name = input('Please input your name: ')
print('Hello,world!' + name)

2.1：注释

该例子可以看到第一句为注释，用#开头

python的注释有两种，单行注释用 #，多行注释用一对三个单引号或者双引号将需要注释的多行包起来，例如：

1
2
3
4
5
"""
# 这是第一个python程序
name = input('Please input your name: ')
print('Hello,world!' + name)
"""

2.2：缩进

python不像C那样会用严格的大括号或者小括号来保证代码正常运行，它通过规范且严格的缩进来保证代码正常运行，在使用一些函数，如if、while、for等结构时，正确的缩进是代码正常运行的第一步，后面在代码示例和其他章节会看到。

2.3：输入

该例子的第二句使用input函数来获取用户输入的内容，并赋值给定义的变量name，后面会详细介绍获取用户输入的数据类型

python交互式命令行会输出input函数内的内容，并等待你的输入，当你输入完成后回车即可，在该例子中回车后，用户输入的内容被赋值给变量name

2.4：输出

该例子的第三句使用print函数输出函数内的内容，字符串Hello，world用单引号引起来，通过 + 将该字符串和变量name对应内容一起输出。

●注：python3中print函数输出的内容必须要用一对小括号括起来，python2不用

3：数据类型和变量

3.1：数据类型分类

常见的数据类型有整型（整数），浮点型（小数），字符串，布尔值，空值

整数和浮点数

整数为int类型，浮点数为float类型。整数除了常见的十进制，还有二进制、八进制、十六进制等，这些进制在代码中的表示都以数字‘0’开头

●注：关于进制转换，这里不做详细讲述，可以自行百度或查找书籍

二进制的表示方法：以0b开头，例如：0b110011代表的就是十进制的51

八进制的表示方法：以0o开头，注意这里的第二个字符是英文小写‘o’

十六进制的表示方法：以0x开头

数字的格式化输出：

何为格式化输出？就是按照规定的格式对数字进行输出，比如小数点后保留几位，左对齐、右对齐还是中心对齐，占位字符长度。格式化输出常用format函数实现，format函数的具体用法看下面的详细举例。

举例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
x = 11585.354654654684
#小数点后保留两位
print(format(x,"0.2f"))
#占位12个字符，小数点后保留1位
print(format(x,'12.1f'))
#占位12个字符，小数点后保留3位右对齐
print(format(x,'>12.3f'))
#占位12字符，小数点后保留两位左对齐，数字后面补0
print(format(x,'0<12.2f'))
#占位12字符，小数点后保留3位，右对齐，数字前面补0
print(format(x,'0>12.3f'))
#占位12字符，小数点后保留3位，中间对齐
print(format(x,'^12.3f'))
#每千位用“，”隔开，小数点后保留5位
print(format(x,',.2f'))

运行结果如下：

format函数的用法还有很多，可以查看该函数的详细用法

字符串

字符串为str类型，一串字符串用引号引起来，注意字符数字和单纯数字的区别

例如：‘456’ 是字符串，而456就是单纯的数字，数字可以用于逻辑运算，字符串就不可以，例如下面的两段代码：

1
2
3
4
a = input('请输入一串数字：')
#并没有对获取到的数字指定为int类型，其复制给a类型是字符串
print('该数加77后的结果为：',(a+77))
#因为a并非数字，所以运行必然报错，结果如下图

1
2
3
a = input('请输入一串数字：')
#输出前，先将变量a转化为数字整型变量，即可与数字相加，得到准确的计算结果
print('该数加77后的结果为：',(int(a)+77))

字符串的输出

当字符串内有特殊字符时，比如\n、\等需要正常输出时，可以使用反斜杠\对特殊字符进行转义，或者直接在字符串前面加‘r’，就可以正常完整输出原来的字符串了

例如：

字符串的格式化

字符串的格式化就是将字符串设置为一个模板，当一个字符串中的部分内容是固定的，例如输出一万个学生的成绩，设置字符串模板进行输出可以更加方便。之前已经提到过format方法，可用于字符串的额标准化输出，format方法也可用于格式化当前的字符串。

1：使用%定义字符串模板

1
2
3
4
5
6
7
8
9
10
11
12
#定义字符串模板
mvban = "%s的数学成绩是%d，语文成绩是%d，英语成绩是%d"
#初始化格式化字符串的参数值，使用元组
name = ('张三','李四','王五')
math = (98,98,97)
chaniese = (89,91,88)
english = (78,79,90)
values = (name,math,chaniese,english)
#输出取值时，也要用%
print(mvban % (values[0][0],values[1][0],values[2][0],values[3][0]))
print(mvban % (values[0][1],values[1][1],values[2][1],values[3][1]))
print(mvban % (values[0][2],values[1][2],values[2][2],values[3][2]))

2：format方法

format方法有别于前面的%定义字符串模板的一点是使用{}来定义字符串模板，同时也可以指定格式化参数的值

1
2
3
4
5
6
7
8
9
10
11
12
#定义字符串模板
mvban = "{name}的数学成绩是{}，语文成绩是{}，英语成绩是{}"
#初始化格式化字符串的参数值，使用元组
name = ('张三','李四','王五')
math = (98,98,97)
chaniese = (89,91,88)
english = (78,79,90)
values = (name,math,chaniese,english)
#注意位置参数是必须先满足, 才能考虑其他可变参数
print(mvban.format(values[1][0],values[2][0],values[3][0],name = values[0][0]))
print(mvban.format(values[1][1],values[2][1],values[3][1],name = values[0][1]))
print(mvban.format(values[1][2],values[2][2],values[3][2],name = values[0][2]))

布尔值

布尔值只有“0”False和“1”True之分

布尔值常用于条件判断，两个布尔值或布尔变量也可以用于and、or、not运算

例如：

1
2
print(5 > 3 and 3 < 1)
print(5 > 3 and 3 > 1)

3.2：变量

变量顾名思义其值可以改变，变量的类型可以为任意数据类型，变量名尤其定义的规则，必须是英文大小写、数字以及“_”的组合，并且不能用数字开头，且不能与语法内的关键字重复，比如定义一个变量就不能使用int，for，from等等这些关键字

整型变量用int类型声明

浮点型变量用float类型声明

字符串用str类型声明

例如：

1
2
3
4
a = 12354
print(int(a)+1)		#整型
print(float(a)+1)	#浮点型
print(str(a)+1)		#字符型，这里无法再像前面一样和数字相加，会报错

4：常见的逻辑运算

加法

除了常见的数字相加，字符串也可以用“+”连接输出

减法

“-”除了能用于减法运算，还能表示负数和列表的切片（切片后面列表章节再细讲）

除法

除法运算，取整使用“/”，例如：5/2的结果为2

取余

除法运算取余使用“%”，例如：5/2的结果为1

幂

幂运算也就是乘方，使用“**”

1
2
3
4
5
6
7
8
9
a = 5
b = 3
c = 15
d = 7
print(a-(-b))   #5-（-3）
print(c/d)      #15/7 非整除
print(c/a)      #15/5 整除
print(c%d)      #15/%7 取余
print(b**(2+2)) #3的4次方

5：列表、元组、字典

5.1：列表

列表是一种有序集合，列表内的元素的数据类型不同于C语言，可以不同，甚至可以为列表本身。

列表的基本操作：赋值、索引、连接、分片

先定义如下的列表：

1
2
3
4
name = ['张三','李四','王五','景一']
age = [18,12,15,21]
information = [name,age]
print(information)

输出结果如下：

可以看到输出的结果仍然为列表

列表可以通过正负数来索引

1
2
3
4
name = ['张三','李四','王五','景一']
age = [18,12,15,21]
print(name[2])
print(age[-1])

输出结果 如下：

列表的切片

1
2
3
4
5
number = [567, 78, 567, 567, 687, 678, 3546, 5765, 576]
print(number[:3])#从第一个数开始取，取前三个数
print(number[1:5])#取第二个到第五个数
print(number[:6:2])#前六个数中，每两个数取一个
print(number[-2:])#取后面两个数

同样的切片用法也可以用于元组

列表生成式

写列表生成式，要把生成的元素或表达式写在前面，后面跟for循环，就可以吧想要的list创造出来，在列表生成式里，for循环后面还可以跟if条件判断用于筛选，也可以进行两层循环生成全排列

1
2
3
4
5
6
7
8
9
#生成一个10以内数字的乘方列表
list = [x*x for x in range(0,10)]
print(list)
#生成一个10以内偶数数字的乘方列表
list = [x*x for x in range(0,10) if x%2 == 0]
print(list)
#使用两层循环，生成全排列
list = [m + n for m in 'abc' for n in "ABC"]
print(list)

5.2：元组

元组的定义

1
2
3
4
5
6
#定义一个空元组
a = ()
#定义一个只含有一个元素的元组
a = (1,)  #定义只含有一个元素的元组时，该元素后面要加上逗号
#定义含有多个元素的元组
a = (1,2,3)

元组的输出

1
2
3
4
5
6
math = (98,98,97)
chaniese = (89,91,88)
english = (78,79,90)
values = (name,math,chaniese,english)
print(values)
print(values[0],[1])

5.3：字典

对于列表来说，查询某个元素的唯一方法就是通过索引，而字典是通过键值对存储的，一个key对应一个value，所以可以直接通过key来查询对应的value，而不需要知道其对应的索引，因此具有极快的查询速度，但其缺点是会占用大量的内存。

字典的定义

1
2
3
#字典的定义
info = {"张三":'027867',"李四":'027867',"王五":'027898'}
#在字典中键是唯一的，并且键是不可变的，第一个值为键（key），第二个值为值（value）

dict函数的使用

使用dict函数可以将其他映射（如其他的字典）或键值对的序列建立字典，例如当返回的值是一个键值对序列的列表，则可以通过dict函数建立字典

1
2
3
4
info = [["张三",'098978'],["李四",'098965'],["王五",'098976']]
print(info)#输出原来的列表
d = dict(info)
print(d)#可以看到原来的列表已近变成键值对形势的字典了

字典的基本操作

  • len(dict)：返回dict中键值对的数量
  • dict(key)：返回key对应的值
  • dict(key) = value :若该key原来存在，重新给该key赋值，若该key不存在，则在key中添加一个新的元素
  • del dict(key)：删除键为key的值
  • key in dict：检查dict中是否含有键为key的值

字典的迭代

1：获取字典的key列表：直接使用for循环对字典中的key进行遍历，也可以使用keys方法

1
2
3
4
5
6
info = [["张三",'098978'],["李四",'098965'],["王五",'098976']]
d = dict(info)
for key in d:
#或者for key in d。keys:
    print(key,end = ' ')
#输出结果为：张三 李四 王五

2：同时获取字典中的key和value列表：使用items方法

1
2
3
4
5
info = [["张三",'098978'],["李四",'098965'],["王五",'098976']]
d = dict(info)
for key,value in d.items():
    print(key,value,end = ' ')
#输出结果为：张三 098978 李四 098965 王五 098976

3：反序列迭代：可以通过reversed函数将一个序列反转

1
2
3
4
5
info = reversed([["张三",'098978'],["李四",'098965'],["王五",'098976']])
d = dict(info)
for key,value in d.items():
    print(key,value,end = ' ')
#输出结果为：王五 098976 李四 098965 张三 098978

6：if条件语句以及while、for循环

if 循环

1
2
3
4
5
n = 10
if n>1 :
    print('number is ' + n)
else :
    print('循环已经结束')

断言

在python中断言需要使用assert语句，在assert关键字后面指定断言的条件表达式，如果不满足条件表达式的内容，就会抛出异常，如果满足就会按照顺序执行后面的语句。

1
2
3
4
a = 10
assert a>9
print("符合条件")
assert a<9, '条件不满足'#为断言指定异常描述信息

while 循环

1
2
3
4
n = 1
while n<5:
    print('当前n的值为：',n)
    n = n + 1

for 循环

打印一个由*号构成的菱形

1
2
3
4
5
6
7
8
9
10
11
12
13
#打印一个自定义高度的由*号构成的菱形，下一层比上一层多两个*号
i = input("请输入要打印的层数：")
i = int(i)
if i < 3:
    print("打印的层数至少大于3")
elif i % 2 == 0:
    print("打印的层数不能为偶数")
else:
    for n in range(1,i,2):
        print(("*"*n).center(i))
        #center方法可以将字符串居中
    for n in range(i-2,1,-2):
        print(("*"*n).center(i))

7：函数

7.1：函数的定义以及三要素

函数是可以调用并且交互的，函数的三个重要因素是函数名、函数参数以及返回值。下面以定义一个使用辗转相除法求最大公约数的函数为例

思路：

1：先判断需要求公约数的两个数a、b是否都大于0

2：判断a和b那个更大

3：c=a%b

4：若C等于0，则b为最大公约数，否则a=b，b=c，继续c=a%b

5：当c=0时，求得最大公约数为b

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#定义一个函数使用def语句
def fun(a,b):
# a和b是该函数的两个参数，用于求a和b的最大公约数
    global c
#在python的函数中，修改操作应该是针对局部变量，如果有和全局同名的变量，
#在修改之前对该变量进行操作自然会出现未定义这样的错误，如果确定要引用全
#局变量，并且要对它修改，就必须加上global关键字并且对其赋初值
    c = 0
    if a<0 or b<0:
        print("请输入两个非零的正数")
    else :
        if (a-b) < 0:
            c = b
            b = a
            a = c
            c = a % b
        while ( c != 0):
            #就是因为这里对c进行了判断，如果不申明c是全局变量并	且赋初值就会报错
            a = b
            b = c
            c = a % b
    return b
        #返回最大公约数 b
#input函数的split方法返回的结果就是列表，直接将获取的内容转化为列表存入list
list = input("请输入两个非零的正数\n").split(' ')

a = int(list[0])
b = int(list[1])
print('a和b的最大公约数是',fun(a,b))

7.2：递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。使用递归函数时要注意栈溢出，即在函数返回时调用自身，并且return语句里不能包含表达式，可以通过尾递归的方式进行优化。

每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

以求n的阶乘为例：

1
2
3
4
5
6
7
8
9
10
11
def fun(n):
    if n == 1:
        return 1
    return n * fun(n-1)
#返回值调用了fun函数而且有乘法表达式
def fun2(n,product):
    if n == 1:
        return 1
    return fun2(n-1,n*product)
#返回值里调用了fun2函数，但没有表达式，将表达式放在参数里，在函数调用之前就进行了计算
# 这样无论调用多少次都不会栈溢出，使递归本身无论调用多少次，都只占用一个栈帧

8：可迭代对象、生成器、迭代器

在学习生成器和迭代器之前需要先了解什么是迭代，何为可迭代对象

8.1：可迭代对象

如果给定一个列表或者元组、字典，我们可以通过for循环来遍历这个列表或元组，这种遍历称之为迭代，而被用来迭代的列表、元组、字典等称其为可迭代对象

在python中迭代是通过for XXX in的结构实现的，而在C语言和其他一些程序语言中，迭代是通过遍历下标索引实现的。对于可迭代对象无论其是否拥有下标，都可以进行迭代，比如字典就可以遍历键或值

练习：使用迭代查找一个list中最小和最大的值，并返回一个元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#定义一个函数用于查找一个list中最小和最大的值，并返回一个元组
def fun(*ss):
    max = int(ss[0])
    min = int(ss[0])
    for i in ss:
        i = int(i)
        if i > max:
            max = i
        elif i < min:
            min = i
    l = (max,min)
    return l
# input函数的split方法直接返回一个列表，将输入的内容转化成列表形式存入list
list = input("请依次输入要求最大值和最小值的数字\n").split(' ')
print(list)
print('最大值和最小值为：',fun(*list))

8.2：生成器

创建一个列表时， 会将列表所有元素装载在内存里，而且是一块连续的内存空间，当一个列表内的元素有很多时，使用列表就会占用过多的内存，而且实际上创建的列表在当时很有可能只用到部分或少量元素，因此生成器（generator）的出现解决了这个问题。

在循环的过程中，通过某种算法不断的推算出后续的元素，边循环边计算的机制就称之为：生成器

（1）：生成器的创建

  • 把一个列表生成式的[]改成()，直接在()里用表达式推算出后续的元素，并生成一个迭代器
  • 用函数来实现，当一个函数定义中含有yield关键字，那该函数就是一个generator，变成generator的函数遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

（2）：示例

1
2
3
4
#求10以内整数的平方，要求通过迭代器实现
g = (x*x for x in range(0,10))
for i in g:
    print(i).

把杨辉三角的每一行看做一个list，用函数写一个生成器，不断输出下一行list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#定义一个生成器
def fun(max):
    max = int(max)
    list = [1]
    if max == 1:
        print(list)
    while max > 1:
        yield list #yield返回一个列表
        list = [1] + [list[n] + list[n + 1] for n in range(len(list)-1)] + [1]
        # 因为每一行的首尾都有1，所以生成新的列表首尾都加上[1]，中间的部分是一个列表生成器，用于生成杨辉三角
        max = max - 1
max = input("请输入最大需要输出几层：\n")
for L in fun(max): #迭代生成器返回的类表
    print(L)

8.3：迭代器

生成器不但可以被for循环遍历迭代，而且可以用next()函数不断调用并返回下一个值，直到最后抛出无法返回的报错。生成器都是迭代器对象，但是列表、字典、字符串等是可迭代对象，却不是迭代器，可以使用iter()函数将其变成迭代器

小结

凡是可作用于for循环的对象都是Iterable(可迭代对象)类型；

凡是可作用于next()函数的对象都是Iterator（迭代器）类型，它们表示一个惰性计算的序列，长度未知，有可能无限。

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

9：高阶函数 map() reduce() lambda()函数

9.1：map函数

map(函数，interable[,…]) map()函数第一个参数为函数，可以str，int，函数名等，第二个参数为可迭代对象(序列)，

map函数的作用是第二个参数对应的序列全部用于第一个参数对应的函数，最终map函数返回结果为新的Iterator，可用list()函数返回的序列转化为list对象

9.2：reduce函数

reduce(函数，序列) 而这个函数必须接收两个参数，第一次使用第二个参数序列中的前两个值，然后reduce把结果继续和序列的下一个元素做累积计算

相当于reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

9.3：lambda函数

lambda()函数为匿名函数，只是一个表达式 用法：lambda 参数1，参数2，…:表达式

1
2
3
4
5
6
7
8
from functools import reduce
def m(x,y):	#m函数接受两个参数
    return x*y		#返回的结果是两个参数的乘积
print(reduce(m,[2,3,4,5]))	
#这里的运算逻辑是：m(m(m(2,3),4),5)=(（（2*3)*4）*5）= 120

print(list(map(lambda x,y:x*y+1,[1,2.3],[4,5,6])))
# lambda函数后面跟了x和y参数，表达式是x*y+1，对应的可迭代对象时两个列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# -*- coding:utf-8 -*-
# 题目：
# 1：将一个列表内的名字转化为首字母大写区其余小写的格式
# 2：利用reduce对一个列表进行求积
# 3：将字符串转化为浮点数
from functools import reduce

def one(names):
	for name in names:
		name	 = name	.capitalize()#caplize()方法可以将字符串的第一个字符转化为大写
		print(name)
		name = name.upper()#uppper()方法将字符串全部转化为大写
		print(name)
		name = name.lower()#lower()方法将字符串全部转化为小写
		print(name)
		name = name[0].upper()+name[1:].lower()#通过切片将字符串首字母大写，其余字符小写
		print(name)

# prod()函数，可以接受一个list并利用reduce()求积：
def prod():
	list1 = []#列表的声明
	for n in range(1,78,7):
		list1.append(n)
	for i in list1:
		print(i)
	print(list1)
	print(reduce(lambda x , y:x*y, list1))

#trandform函数可以将一个字符串转化为浮点数
def transform(money):
	print(len(money))
	#定义各一个字典，用于字符转化为数字
	digits = { '0':0 , '1':1 , '2':2 , '3':3 , '4':4 , '5':5 , '6':6 , '7':7 , '8':8 , '9':9 }
	list2 = [ digits[i] for i in money if i is not '.' ] 
	#上面的句子完成了：①for循环遍历字符串②if判断③通过遍历字符串去字典调用字符相对的数字
	if '.' in money:
		point_in = len(money) - money.index(".") - 1 #计算出 .  在字符串中的相对位置
		print(reduce(lambda x , y:x*10+y , list2) * 10  ** (-point_in))#计算对应的浮点数
	else :
		print(reduce(lambda x , y:x*10+y , list2) )

def  main():
# map函数第一个参数为函数，第二个为interable，这里用input直接获取，并用split方法指定分隔符对字符串进行切片
	name = list(map(str,input("请输入你们团队成员的名字：").split()))
	one(name)
	money = input("请输入一个浮点数：")
	prod()
	transform(money)



if __name__ ==  "__main__":
	main()

10：类和实例以及方法和属性

面向对象编程

在python中所有的数据类型均可视作为对象，也可自定义对象，自定义的对象的数据类型就是类。面向对象编程是一种程序设计思想，把对象当做程序的基本单元，一个对象包含了数据和操作数据的函数。就比如Student，学生看做一类对象，而一个学生有姓名、年龄、成绩等多种属性，当需要处理学生的成绩时，向Student发送消息，让其执行对应的关联函数，这里的关联函数就是对象的方法，给某个对象发送消息让其执行它的某一方法，这就是面对对象编程。

10.1：类和实例

类是一个抽象概念，比如Student类，用来描述学生一类对象，而学生这一类对象里有很多个单独的个体，每一个具体的个体称为实例，因此实例是根据对象创建的一个个具体的个体，各自的数据可能有所不同。

类的定义

类是通过class关键字定义的：

1
2
class 类名(首字母大写) (继承类名):
    pass

通常，如果没有合适的继承类，就使用object类

实例的创建

创建实例是通过：类名 + （）实现的

1
2
3
class Student (object):	#定义了一个Student的类
	pass
Lili = Student()#创建了一个叫Lili学生的实例

10.2：方法和属性

创建类时，通过定义一个特殊的__init__方法，该方法能把我们认为必须绑定的属性强制写进去，那何为属性呢？对于一个学生的实例，年龄、性别、学号等都可以是该实例的属性，每个实例都可以自定义自己独有的属性，但像学号、性别、年龄这些必须的属性就可以写在Student类的__init__方法中，这样在每创建一个实例时都会包含这些必须属性。

创建一个汽车Car类，分析类、实例、方法、属性之间的关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#创建一个汽车的类
class Car(object):
    def __init__(self, brand, make, year, color):
    #__init__方法的第一个参数永远是self，表示创建的是实例本身，
    #下面把各种属性绑定到self，因为self就指向创建的实例本身
        self.brand = brand
        self.make = make
        self.year = year
        self.color = color
    #定义一个方法，打印输出车辆的信息
    def print_info(self):   #由于不需要其他参数，这里只需要self属性，就可以使用__init__方法中的所有属性了
        print("这辆车的信息为：%s品牌，由%s在%d年制造，车身为%s色" % (self.brand,self.make,self.year,self.color))
#创建一个Car的实例
my_car = Car('特斯拉', '美国', 2019, '宝蓝')
#创建了一个Car的实例my_car，类Car的__init__方法中包含的属性要赋值
my_car.print_info() #调用Car类里的print_info()方法

访问限制

在类内部，有属性和方法，外部代码可以直接调用实例变量的方法来操作数据，要想内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在python中，实例的变量名如果以__开头，该变量就变成了一个私有变量，只有内部可以访问，外部不能访问，除非在类中添加供访问或修改的方法，才可以访问或修改。

1
2
3
4
5
6
7
8
#将上面代码的year改为私有变量
class Car(object):
    def __init__(self, brand, make, year, color):
    #__init__方法的第一个参数永远是self，表示创建的是实例本身，
    #下面把各种属性绑定到self，因为self就指向创建的实例本身
        self.brand = brand
        self.make = make
        self.__year = year	#将year修改为私有变量

运行抱错：AttributeError: 'Car' object has no attribute 'year'

在类中，定义一个调用year的方法get_year才可以调用该变量

1
2
3
4
5
#定义一个方法，打印输出车辆的信息
   def get_year(self):
       print(self.__year)
   #通过方法调用
   my_car.get_year()

运行能够正常输出：2019

10.3：类的继承

在面向对象程序设计时，当我们定义一个类时，可以从以前的定义的类继承，新的class称为子类，而被继承的class是父类

例如前面的Car可以看做一个大类，而定义子类：newpower_car和traditional_car两种子类，代表新能源汽车和传统汽车，子类可以获得父类的所有功能，除此之外自己也可以定义新的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#创建一个汽车的类
class Car(object):
    def __init__(self, brand, make, year, color):
    #__init__方法的第一个参数永远是self，表示创建的是实例本身，
    #下面把各种属性绑定到self，因为self就指向创建的实例本身
        self.brand = brand
        self.make = make
        self.year = year
        self.color = color
    #定义一个方法，打印输出车辆的信息
    def print_info(self):   #由于不需要其他参数，这里只需要self属性，就可以使用__init__方法中的所有属性了
        print("这辆车的信息为：%s品牌，由%s在%d年制造，车身为%s色" % (self.brand,self.make,self.year,self.color))

#定义新能源汽车子类Newpower_car
class Newpower_car(Car):
    def __init__(self, brand, make, year, color,mileage):
        super().__init__(brand, make, year, color)
        #super().__init__()用于初始化父类的属性
        self.mileage = mileage  #初始化子类的属性
    def print_mileage(self):
        print("\n它的最大里程数为：%d公里" % (self.mileage))
my_car = Newpower_car('特斯拉', '美国', 2019, '宝蓝', 580)
my_car.print_info() #调用继承父类的方法
my_car.print_mileage()  #调用子类的方法




FEATURED TAGS
Python
FRIENDS