2021-05-05

最近相对整块时间比较多，所以决定把python的一些知识复习一下：

python的一些数字类型：

整型
浮点型
布尔类型(特殊的整型)
e记法 1.5e10（并非数字类型）

分支与循环：

需求：为了方便成绩判定，请将分数为大于等于90分小于100分判定为A, 分数大于等于80分小于90分判定为B, 分数大于等于70分小于80分判定为C, 分数大于等于60分小于10分判定为D。
score = int(input("请输入一个分数"))
if 100 >= score >= 90:
    print("A")

elif 90 > score >= 80:
    print("B")

elif 80 > score >= 70:
    print("C")

elif 70 > score >= 60:
        print("D")

else:
    print("输入错误")

三元操作符

例：x,y = 4,5
    if x < y:
    small = x
    else:
    small = y

例子可以改进为：small = x if x < y else y

断言（assert）

assert 3 > 4

AssertionError

assert 3 < 4

程序正常运行

While循环

while 条件：
    循环体

for循环:

    for 目标(变量) in 表达式（列表，元组）:
    循环体

range()（for 循环的小伙伴）
range([strat,] stop[, step = 1])

for i in range(1,10,2):
    print(i)

1

3

5

7

9

break和continue

break:终止当前循环并跳出当前循环体
continue:终止本轮循环并开启下一轮循环

continue范例：
 for i in range(10):
    if i%2 != 0:
        print(i)
        continue
    i += 2
    print(i)
2

1

4

3

6

5

8

7

10

9

列表：一个打了激素的数组

append()（只有一个参数，准备插入列表的元素）

extend()(只有一个参数，列表作为其参数)

向列表添加参数的两个方法。

insert()(两个参数)（插入列表的位置，准备插入的元素）

删除列表元素：

remove()(不需要知道具体位置，知道元素的名字即可)

del语句
del + 列表名字会删除整个列表

pop()
member.pop()(删除列表最后一个元素)

列表分片（slice）
memeber[1:3](原列表的一个拷贝)

member[:3]
member[1:]
member[:]

列表的一些常用操作符：

比较操作符：< >

逻辑操作符: and

连接操作符: +(两个列表相加)

重复操作符: list3 * 3 ; list3 *= 3

成员关系操作符: in 、 not in 

list = ['小甲鱼'， ['老甲鱼'，'牡丹']，'玩具']

'老甲鱼' in list[1]
True

list[1][1]
'牡丹'

列表类型的内置函数

count()

index()

reverse()(两级反转)（不需要参数）

sort(func(算法), key（与算法搭配的关键字), reverse)（排序）

sort(reverse = True)

元组：

tuple = (1,2,3,4,5,6,7,8,9,10)

8*8

64

8 * (8,)

(8,8,8,8,8,8,8,8)

如何给元组增加元素：

temp = ('1', '2', '3', '4')
temp = temp[:2] + ('敏儿',) + temp[2:]
temp
('1', '2', '敏儿', '3', '4')

用del可以删除整个元组

哪些操作符可以运用在元组之上呢？它和列表是一样的

比较操作符：< >

逻辑操作符: and

连接操作符: +(两个列表相加)

重复操作符: list3 * 3 ; list3 *= 3

成员关系操作符: in 、 not in

字符串也能进行切片操作：

str1 = "I love 123"

str1[5]

'e' 
字符串常用的方法：
capitalize() 把字符串的第一个字符改为大写

casefold() 把整个字符串的所有字符改为小写

center(width) 将字符串居中，并使用空格填充至长度 width 的新字符串

str2 = 'DAXIExiaoxie'
str2.center(40)
'                                              DAXIExiaoxie                                              '                                                                                             

count(sub[,start[,end]])返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。

string2.count('xi')
2

encode() 表示编码

endswith(sub,[,start[,end]]) 检查字符串是否以 sub 子字符串结束，如果是返回 True，否则返回 False。start 和 end 参数表示范围，可选。

str2.endswith('xi')
False

str2.endswith('xie')
True

expandtabs([tabtize = 8]) 把字符串中的 tab 符号（\t）转换为空格，如不指定参数，默认的空格数是 tabsize=8。

str3 = "I\tlove\tFishC.com"
str3.expandtabs()
'I       love    FishC.com'

find(sub[,start[,end]]) 检测 sub 是否包含在字符串中，如果有则返回索引值，否则返回 -1，start 和 end 参数表示范围，可选。

str3.find('efc')
-1

str3.find('com')
13

index(sub[,start[,end]]) 跟 find 方法一样，不过如果 sub 不在 string 中会产生一个异常。

join(sub) 以字符串作为分隔符，插入到 sub 中所有的字符之间。

str6 = 'Fishc'
str6.join(12345)
'1Fishc2Fishc3Fishc4Fishc5'

split(sep = None, maxsplit = 1) 不带参数默认是以空格为分隔符切片字符串，如果 maxsplit 参数有设置，则仅分隔 maxsplit 个子字符串，返回切片后的子字符串拼接的列表。

str6 = 'I love fishc'
str6.split()
['I', 'love', 'fishc' ]

str6.split(I)
['', 'love', 'fishc']

strip([chars]) 默认去字符串两边的空格，也可以自己指定参数

str7 = '         ssssaaaa       '
str7.strip()
'ssssaaaa'
str7 = str7.strip()
str7
'ssssaaaa'
str7.strip('s')
'aaaa'

swapcase() 字符串大写变小写，小写变大写

title() 单词首字母大写

translate(table) 变换字符串其中的内容

str7 = 'ssssaaaa'
str7.translate(str, maketrans('s', 'b'))
'bbbbaaaa'

islower() 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回 True，否则返回 False。

str4 = '小甲鱼'
str4.islower()
False

istitle() 如果字符串是标题化（所有的单词都是以大写开始，其余字母均小写），则返回 True，否则返回 False。

str5 = 'FishC'
str5.istitle()
False

lstrip() 去掉字符串左边的所有空格
str6 = '      I love you.'
str6.lstrip()
'I love you.'

partition(sub) 找到子字符串 sub，把字符串分成一个 3 元组 (pre_sub, sub, fol_sub)，如果字符串中不包含 sub 则返回 ('原字符串', '', '')
str6 = 'I love you.'
str6.partition(ov)
('I l', 'ov', 'e you.')

replace(old,new[,count]) 把字符串中的 old 子字符串替换成 new 子字符串，如果 count 指定，则替换不超过 count 次。

str6 = 'I love fishC.'
str6.replace('fishC', 'FishC')
'I love FishC.'

swapcase()

str = 'FishC'
str.swapcase()翻转字符串中的大小写。
'fISHc'

Python中的format()
format()接受位置参数和关键字参数
replacement用花括号表示
"{0} love{1}.{2}".format("I", "FishC", "com")
'I love FishC.com'

"{a} love{b}.{c}".format(a="I", b="FishC", c="com")
'I love FishC.com'

"{0} love{b}.{c}".format("I", b="FishC", c="com")

print('\ta')
    a

print('\\')
\

"{{0}}".format("不打印")
'{0}'

'{0:.1f}{1}'.format(27.658, 'GB')
'27.7GB'

字符串格式化符号含义及转义字符含义：

%c 格式化字符及ASCII码

'%c' % 97
'a'

'%c %c %c '% (97, 98, 99)
'a, b, c'

%s 用字符串格式化字符串
'%s' % 'I love you' 

%d 格式化整数

'%d + %d = %d' % (4, 5, 4+5)
'4+5 = 9'

%o格式化无符号八进制数

'%o' % 10
12

%x格式化无符号十六进制数
'%x' % 10
a

%X格式化无符号十六进制数
'% X' % 10
A

'%X' % 160
'A0'

%f格式化定点数,可指定小数点后的精度
'%f' % 27.658
'27.658000'

%e用科学计数法格式化定点数
'%e' % 27.658
'2.765800e + 01'

格式化操作符辅助指令
m,n m是显示的最小总宽度，n是小数点后的位数

'%5.1f'% 27.658
'  27.7'

'%.2e' % 27.658
'2.77e+01'

-用于左对齐
'%-10d'% 5
'5          '

+在正数面前显示加号
'+d' % 5
'+5'

'+d' % -5
'-5'

#在八进制面前显示（'0'）,在十六进制面前显示'0x'或'0X'
'%#o' % 10
0o12

'%#X'% 108
'0X6C' 

'%d'% 10
10

0显示的数字前面填充'0'取代空格
'010d'% 5
'0000000005'

'%0-10d' % 5
'5         '

列表、元组、字符串的共同点：

-都可以通过索引得到每一个元素

-默认索引值总是从0开始

-可以通过分片的方法得到一个范围内元素的集合

-有很多共同操作符（重复操作符，拼接操作符，共同成员操作符）

序列的内置函数：

list([iterable]):把一个可迭代对象转换为列表

tuple([iterable]): 把一个可迭代对象转换为元组

str(obj):把obj对象转换为字符串

len(sub):返回参数sub的长度

max():返回序列或者参数集合中的最大值

min()返回序列参数集合中的最小值

Python3 中有六个标准的数据类型：
 
Number（数字）

String（字符串）

List（列表）

Tuple（元组）

Set（集合）

Dictionary（字典）

sum(iterable,[, start=0])返回序列iterable和可选参数start的总和

sorted() 对序列中的数值大小进行排序

reversed()
numbers = [1, 2, 3, 4]
list(numbers(reversed))
[4, 3, 2, 1]

enumerated()
numbers = [1, 2, 3, 4]
list(enumerated(reversed))
[(0,1), (1,2), (2,3), (3,4)]

zip()
a = [1, 2, 3, 4, 5, 6, 7, 8]
b = [1, 2, 3, 4, 5]
list(zip(a, b))
[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]

函数：

关键字：
def；return

形参与实参，函数的参数可以为无限个

写函数功能文档是种好习惯哦

函数介绍：函数名.__doc__ ; help(函数名);

关键字参数：

def saysome(name, words):
    print(name + '->' + words)

saysome('敏儿'，'让编程改变世界！')
敏儿->让编程改变世界！

saysome(words= '让编程改变世界！, name= '敏儿')
敏儿->让编程改变世界！

默认参数:

def saysome(name='敏儿', words='让编程改变世界！'):
    print(name + '->' + words)

saysome()
敏儿->让编程改变世界！

saysome('大猪蹄子')

大猪蹄子->让编程改变世界！

收集参数：

def test(*params):
    print('参数的长度是：', len(params))
    print('第二个参数是：', params[1])

test(1, '敏儿', 3.14, 5, 6, 7, 8)
参数的长度是：7
第二个参数是：敏儿

闭包：

defX(x):
    defY(y):
        return x*y
    return FunY

def fun1():
    x = 5
    def fun2():
        x *= x
        return x
    return fun2

def fun1():
    x = 5
    def fun2():
        x[0] *= x[0]
        return x[0]
    return fun2

fun1()
25

def fun1():
    x = 5
    def fun2():
        nonlocal x
        x *= x
        return x
    return fun2

nonlocal不是全局变量

lambda函数

def ds(x):
    return 2 * x+1

ds(5)
11

lambda x : 2 * x + 1
g = lambda x : 2 * x + 1
g (5) 
11

def add(x, y):
    return x + y

add(3, 4)
7

lambda x, y : x + y
g = lambda x, y : x + y
g(3, 4)
7

两个牛逼的函数：
filter()
filter(None, [1, 0, True, False])

list(filter(None, [1, 0, True, False]))

[1, True]

利用filter函数筛选奇数：

def odd(x):
    return x % 2

temp = range(10)
show = filter(odd, temp)
list(show)
[1, 3, 5, 7, 9]

list(filter(lambda x : x % 2, range(9)))
[1, 3, 5, 7, 9]

map()函数
list(map(lambda x : x % 2, range(9)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

递归是神马

def factorial(n):
    result = n
    for i in range(1, n):
        result* = i

    return result

number = int(input('请输入一个正整数：'))
result = factorial(number)
print()

闭包：

defX(x):
    defY(y):
        return x*y
    return FunY

def fun1():
    x = 5
    def fun2():
        x *= x
        return x
    return fun2

def fun1():
    x = 5
    def fun2():
        x[0] *= x[0]
        return x[0]
    return fun2

fun1()
25

def fun1():
    x = 5
    def fun2():
        nonlocal x
        x *= x
        return x
    return fun2

nonlocal不是全局变量

lambda函数

def ds(x):
    return 2 * x+1

ds(5)
11

lambda x : 2 * x + 1
g = lambda x : 2 * x + 1
g (5) 
11

def add(x, y):
    return x + y

add(3, 4)
7

lambda x, y : x + y
g = lambda x, y : x + y
g(3, 4)
7

两个牛逼的函数：
filter()
filter(None, [1, 0, True, False])

list(filter(None, [1, 0, True, False]))

[1, True]

利用filter函数筛选奇数：

def odd(x):
    return x % 2

temp = range(10)
show = filter(odd, temp)
list(show)

[1, 3, 5, 7, 9]

list(filter(lambda x : x % 2, range(9)))
[1, 3, 5, 7, 9]

map()函数
list(map(lambda x : x % 2, range(9)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

递归是神马

def factorial(n):
    result = n
    for i in range(1, n):
        result *= i

    return result

number = int(input('请输入一个正整数：'))
result = factorial(number)
print("%d的阶乘是: %d" % (number, result))

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)

number = int(input('请输入一个正整数：'))
result = factorial(number)
print("%d的阶乘是: %d" % (number, result))

斐波那契数列：

def fab(n):
#此处n为时间
    n1 = 1
    n2 = 1
    n3 = 1

    if n < 1:
        print('输入有误！')
        return -1
    while (n-2) > 0:
        n3 = n2 + n1
        n1 = n2
        n2 = n3
        n -= 1

       return n3

result = fab(20)
if result!= -1:
    print("总共有%d对小兔崽子诞生！" % result)

def fab(n):
    if n < 1:
        print('输入有误！')
        return -1

    if n == 1 or n == 2:
        return 1
    else:
        return fab(n-1) + fab(n-2)

result = fab(20)
if result != -1:
    print("总共有%d对小兔崽子诞生！" % result)

 

字典

name = ['黑夜'，'一束光', '敏儿', '秀乐']
slogen = ['技术第二', '人品第一', '还会再见嘛', '会再见的']
print('秀乐的口号是：'，slogen[name.index('秀乐')])
秀乐的口号是：会再见的

dict1 = {'黑夜'：'技术第二', '一束光':'人品第一', '敏儿': '还会再见嘛' '秀乐':'会再见的'}
print('秀乐的口号是 :', dict1['秀乐'])（键的值：整型，变量，字符串，字符类型）
秀乐的口号是：会再见的

dict2 = {1:'one', 2:'two', 3:'three'}
dict[2]
two

dict3 = {}

dict3 = dict((('F',70), ('i', 105), ('s', 115), ('C', 67)))
dict3
{'F': 70, 'C': 67, 's': 115, 'h': 104, 'i': 105}

注：其中dict(mapping)的参数只有一个，所以要在外面多加两个括号。

dict4 = dict(敏儿= '你不懂我我也不怪你', 秀乐= '我还是无法理解')
dict4
{ '秀乐':'我还是无法理解','敏儿':'你不懂我我也不怪你',}

注：如果通过关键字参数创建字典，键值对可能会产生顺序上的变化。

通过关键字参数创建字典，其中的“敏儿”和“秀乐”不能加引号否则会报错。

dict4 = ['秀乐']= '所有从业者都要通过学习编程来提高职业技能'
dict4 
{'秀乐': '所有从业者都要通过学习编程来提高职业技能', '敏儿': '你不懂我我也不怪你'}

dict4['爱迪生'] = '天才就是99%的汗水加1%的灵感，但这1%的灵感远比99%的汗水重要'
dict4
{'秀乐': '所有从业者都要通过学习编程来提高职业技能', '敏儿': '你不懂我我也不怪你', '爱迪生': '天才就是99%的汗水加1%的灵感，但这1%的灵感远比99%的汗水更重要。'}

当索引不好用时：
dict（工厂函数）
str()
int()
list()
tuple()
以上均为类型函数。

fromkeys()（创建并返回一个新的字典）
dict.fromkeys(s[,v]) （s,代表的是字典对应的键值。v时可选的，如果第二个参数不提供时，它默认的就是None）

dict1 = {}
dict1.fromkeys((1, 2, 3))
{1:None, 2:None, 3:None}
dict1.fromkeys((1, 2, 3), 'Number')
{1:'Number', 2: 'number', 3: 'number'}

dict1.fromkeys((1, 2, 3), ('one', 'two', 'three'))
{1: ('one', 'two', 'three'), 2:('one', 'two', 'three'),3:('one', 'two', 'three')}

dict1.fromkeys((1,3), '数字')
{1: '数字'，3: '数字'}

keys()返回字典键的引用
values()
items()
访问字典的几个方法

dict1 = dict1.fromkeys(range(32), '赞')
dict1
{0: '赞', 1: '赞', 2:'赞'...}
for eachkey in dict1.keys():
    print(eachkey)
0
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

for eachvalue in dict.value():
    print(eachvalue)
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞

for eachItem in dict1.fromkeys():
    print(eachItem)
(0, '赞')
(1, '赞')
(2, '赞')
(3, '赞')
(4, '赞')
(5, '赞')
(6, '赞')
(7, '赞')
(8, '赞')
(9, '赞')
(10, '赞')
(11, '赞')
(12, '赞')
(13, '赞')
(14, '赞')
(15, '赞')
(16, '赞')
(17, '赞')
(18, '赞')
(19, '赞')
(20, '赞')
(21, '赞')
(22, '赞')
(23, '赞')
(24, '赞')
(26, '赞')
(27, '赞')
(28, '赞')
(29, '赞')
(30, '赞')
(31, '赞')

print(dict1[32])
keyerror

dict1.get(32)
print(dict1.get(32))
None

clear()方法  (清空字典)
dict1.clear()
dict1()
{}

浅拷贝和赋值是不一样的：
a = {1: 'one', 2: 'two', 3: 'three'}
b = a.copy()
c = a

a.pop(2)
'two'
a
{1: 'one', 3: 'three'}

a.popitem()
{1: 'one'}
a
{3: 'three'}

a.setdefault('小白')
{'小白': None, 3: 'three'}

a.setdefault(5: 'five')
five
a
{'小白':None, 5: 'five', 3: 'three'}

b = {'小大白': '狗'}
a = update.b
a
{'小大白': '狗', '小白':None, 5: 'five', 3: 'three'}

 

集合：

num = {}
num2 = {1, 2, 3, 4, 5}
num2 = {1, 2, 3, 4, 5, 5, 4, 3, 2, 1}
num2
{1, 2, 3, 4, 5}

注：集合具有唯一性，集合不支持索引。

set1 = set([1, 2, 3, 4, 5])
set1
{1, 2, 3, 4, 5}

如何访问集合中的值：
1.可以使用for把集合中的数据一个个都取出来
2.可以通过in和not in判断一个元素是否在集合中已经存在

num2 = {1, 2, 3, 4, 5}
num2.add(6)
num2
{1, 2, 3, 4, 5, 6}
同理还有remove()方法

不可变集合L:
frozen
num3 = frozenset({1, 2, 3, 4, 5})
num3.add()
报错
文件

 

模块：

OS模块：Operating System（操作系统）

OS模块下的函数：(模块必须先导入)
getcwd()
chdir(path)(path需为字符串形式)
listdir()(列举当前目录的文件名)
mkdir()(创建当前文件夹)
mkdirs(path)(递归创建多层目录)
remove(path)(删除文件)
rmdir()(删除单层目录，如目录非空就会报错)
removedirs(path)(删除多层目录，在此之前先删除其中的子目录及文件)
rename(old, new)(将文件old重命名为new)
system(command)运行系统的shell命令
os.curdir 指代当前目录(".")
os.pardir 指代上一级目录("..")
os.sep 输出操作系统特定的路径分隔符：(Win下为'\\', Linux下为'/')
os.linesep 当前系统使用的行终止符(Win下为'\r\n', Linux下为'\n')
os.name 指代当前的操作系统(包括：'posix', 'nt', 'mac', 'os2', 'ce', 'java')

os.path模块中关于路径常用的函数使用方法：

basename(path) 去掉目录路径，单独返回文件名
dirname(path)去掉文件名，单独返回目录路径
join(path1[,path2[,...]])
split(path)(分割文件名和路径)
splitext(path)分离文件名和扩展名
getsize(file)返回指定文件的尺寸，单位是字节
getatime(file)返回指定文件最近的访问时间
getctime(file)返回指定文件的创建时间
getmtime(file)返回指定文件最新的修改时间
exists(path)判断指定路径（目录或文件）是否存在
isabs(path)判断指定路径是否为绝对路径
isdir(path)判断指定路径是否存在且是一个目录
isfile(path)判断指定路径是否存在且是一个文件
islink(path)判断制定路径是否存在且是一个符号链接
ismount(path)判断指定路径是否存在且是一个挂载点
samefile(path1, path2)判断path1和path2两个路径是否指向同一个文件

文件的永久储存：
import pickle
my_list = [1, 3.14, 'dog', ['another list']]
pickle_file = open('my_list.pk1', 'wb')
pickle.dump(my_list, pickle_file)
pickle_file.close()

pickle_file = open('my_list.pk1', 'rb')
my_list2 = pickle.load(pickle_file)
print(my_list2)

Python标准异常总结：

AssertioneError 断言语句(assert)失败

AttributeError 尝试访问未知的对象属性

IndexError 索引超出序列的范围

KeyError 字典中查找一个不存在的关键字

NameError 尝试访问一个不存在的变量

OSError 操作系统产生的异常（例如打开一个不存在的文件）

OverflowError 数值运算超出最大限制

SyntaxError python的语法错误

TypeError 不同类型间的无效操作

ZeroDivisionError 除数为零

异常检测：

try:
    检测范围
except Exception[as reason]:
    出现异常(Exception)后的处理代码
finally:
    无论如何都会被执行的代码

try:
    sum = 1 +'1'
        f = open('我为什么是一个文件')
    print(f.read())
    f.close()
except OSError as reason:
    print('文件出错啦\n出错的原因是：' + str(reason))
except TypeError as reason:
    print('类型出错啦\n出错的原因是：' +str(reason))

try:
    sum = 1 +'1'
        f = open('我为什么是一个文件')
    print(f.read())
    f.close()

except(OSError, TypeError):
    print('出错啦-_-')

try:
    f = open('我为什么是一个文件.txt', 'w')
    print(f.write('我存在了！'))
    sum = 1 + '1'

except(OSError, TypeError):

raise:自己引发一个异常

raise ZeroDivisionError('除数为0的异常')
ZeroDivisionError：除数为0的异常

    print('出错啦-_-')
finally
    f.close()

else的丰富用法：

def showMaxFactor(num):
    count = num // 2
    while count > 1:
        if num % count ==0:
            print('%d最大的约数是%d' % (num, count))
    else:
        print('%d是素数！'% num)

num = int(input('请输入一个数'))
showMaxFactor(num)

简洁的with语句

try:
    with open('data.txt', 'w') as f:
        for each_line in f:
        print(each_line)
except OSError as reason:
    print('出错啦' + str(reason))

面向对象的特征：
1.封装（属性和方法）
2.继承（子类自动共享父类之间数据和方法的机制）
3.多态
Class A:
    def fun(self):
        print("我是小A")
Class B:

    def fun(self):
        print("我是小B")
a = A()
b = B()
a.fun()
我是小A
b.fun()
我是小B

class Ball:
    def setName(self, name):
        self.name = name
    def kick(self):
        print("我叫%s, 该死的,谁踢我..." % self.name)

a = Ball()
a.setName('球A')
b = Ball()
b.setName('球B')
c = Ball('土豆')
a.kick()
我叫球A，该死的，谁踢我...
c.kick()
我叫土豆，该死的，谁踢我...

你听说过python的魔法方法嘛
__init__(self) 构造

class Ball:
    def __init__(self, name):
        self.name = name
    def kick(self):
        print("我叫%s, 该死的,谁踢我..." % self.name)

b = Ball('土豆')
b.kick()
我叫土豆，该死的，谁踢我...

公有和私有
class Person:

    __name = '小甲鱼'
    def getName(self):
        return self.__name

p = person()

p.__name

p.getName()
'小甲鱼'
p._person__name 
'小甲鱼'