初学python语法基础

自用学习，整理一下python的基本语法（开发工具pycharm， python版本3.6，运行环境win10）

因为之前也写过c,java等别的语言，所以记录的不会很细致。

参考内容：菜鸟教程 python3教程

一.输出

        

#输出
print ("Hello,Python!")
#注释是使用“#”来表示的

#多行注释可以用 ''' 和 """来分割

运行结果

python默认print输出是换行的，如果希望不换行则在print末尾加上end=""

print("A")
print("B")
print(end="A")
print(end="B")

运行结果

二.行与缩进

与c,java等语言不同，python 不需要使用 { } 大括号来限定代码的范围，它使用 缩进来表示代码块。

同一个代码块的语句必须包含相同的缩进空格数

    

a=1

if a>0 :
    print("true")
else:
    print("false")

运行结果

如果缩进空格数不一样，则会报错（在敲代码的时候，pycharm会报红提醒）

a=1

if a>0 :
    print("a>0")
     print("true")
else:
    print("false")

运行结果

三.多行语句

 尽量把语句控制在一行，如果超过一行可以利用反斜杠\ 来进行分行，在[],{},()中的内容不需要

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']


print(total)


total1 = ['item1','item'
                 '2']
print(total1)

运行结果

ps: 我一开始以为他说的不需要反斜杠是数组种列举的每个元素之间用逗号隔开，不影响整个数组的定义，但是从运行结果可以知道它居然是真的可以把一个元素的内容隔开（仅限字符串一类，整数之类的不行），不用写 \ 或者是+ ，好神奇。

四.字符串

1. python中 ' '和“”使用完全相同，都可以用来表示字符串。
2. 转义字符用法和其他语言无异，但是使用r 可以让反斜杠不转义

str = "this is a line\n"
str1 = r"this is a line\n"


print(str)
print(str1)

运行结果

        3.字符串可以用+连接，用*重复

str = 'this '+'is '+'string '
str1 = 'this '*2
str2 = str*2


print(str)
print(str1)
print(str2)

运行结果

        4.python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始

str = "123456789"


print(str[0])  #输出第一个字符 ‘1’
print(str[-1])   #输出倒数第一个字符 ‘9’
print(str[0:-1])  #输出从第一个字符到倒数第二个字符，不包括最后的str[-1]
print(str[0:])    #输出从第一个开始后的所有字符
print(str[0:6:2])  #输出从str[0]到str[5]每隔一个字符的字符

运行结果

        5. 没有字符类型，只有字符串（本人觉得更神奇了），字符就是长度为1的字符串

        6.字符串的截取的语法格式如下： 变量[头下标:尾下标:步长]

五. 导入格式

整个模块导入：import somemodule

将某个模块的某个函数导入： from somemodule import somefunction

将某个模块的所有函数导入：from somemodule import *

六.python的基本数据类型

python不同于其他语言，python变量不需要声明，每个变量声明即赋值

并且允许多个变量赋值。

a=b=c=1

a,b,c=1,2,"A"

Python一共有六种标准数据类型：

（1）Number (数字) （2）String (字符串) （3）List (列表) （4）Tuple(元组) （5）Set (集合) （6）Dictionary(字典)

（1）Number(数字)

支持int,float,bool,complex(复数)。比较特别的是复数

a=1+2j      #复数表示是a+bj形式，另外还可以用complex(a,b)表示
print(a)    #打印a
print(type(a))  #打印a类型

运行结果

• 在python3中，会认为bool 是int的子类，所以bool类型也可以用1，0判定
• 在进行除法运算时，/ 运算符会返回一个浮点数， //会返回一个整数
• 混合运算时，python会把整型转换成浮点型

（2）String(字符串)

参见上文 标题为四模块

（3）List(列表)

• 和其他语言的数组类型大致类似，但可以反向索引，末尾是-1，向前是-2，类似于数轴。
• 截取列表中的内容：list[头下标：尾下标]。
• 列表连接运算符：+，重复操作：*。
• 和字符串一样，也可以接收第三个参数来实现内容截取，list[0:5:2] 结果就是ACE。

#list列表
list=['A','B','C','D','E','F','G']
list2=['1','2']
print(list)
print(list2)
print(list[0:3])
print(list[1:])
print(list+list2)
print(list2*2)

运行结果

• 特别的一点：python中字符串中的字符不可以改变，而列表中的元素可以改变。

list=['A','B','C','D','E','F','G']
str='ABCDEFG'


print(list)
print(str)
list[0]='Z'
str[0]='Z'
print(list)
print(str)

运行结果

可以看见报错在str[0]='Z'这一行

将这一行注释掉之后

运行结果（list第一个元素被改变成了Z）

（4）Tuple(元组)

其他语言好像没有元组这个概念，python中的元组与列表类似，不同之处在于元组的元素不能修改，写在小括号里，元素之间用逗号隔开。

• 元素不能修改
• 写（）
• 一个元组中元素可以是不同类型
• 含0个或1个元素的元组比较特殊，有额外规则：tuple=()表示空元组，tuple=(1,)只有一个元素的元组在定义时要在第一个元素后面加一个逗号

tuple = ('abcd',1,3.14,True)


print(tuple)
print(tuple[1:])
print(tuple[-1])

运行结果

（5）Set集合

集合是一个不重复无序的元素序列（区别以上列表，元组，他们都是有序且可以重复的）

集合基本功能是进行成员关系测试和删除重复元素

basket={'apple','orange','pear','apple','grape'}  #定义用{}花括号
print(basket)       #输出是不重复的


#成员测试
if 'orange' in basket:
    print('orange is in basket')
else :
    print('orange is not in basket')


#集合运算
a=set('abracadabra')  #定义时也可以使用set()函数，应该是属于构造函数了
b=set('alacazam')


print(a)    #要记住集合是不重复的
print(b)
print(a-b)  #差集
print(a|b)  #并集
print(a&b)  #交集
print(a^b)  #a,b中不同时存在的元素

运行结果

（6）Dictionary(字典)

字典是一种映射类型，是无序的对象集合，（所以说它本身就是集合），集合中的元素具有键（key）:值（value）,形成一种对应的关系。（有点像jason）

dict={'name':'ruby','age':20,'sex':'female'}  #定义
print(dict)
print(dict['name'])    #输出name对应的值
print(dict.keys())     #输出所有键
print(dict.values())   #输出所有值

运行结果

ps: 字典最重要就是有key:value键值对的这个对应关系

七.数据类型转换

python数据类型转换分为两种：（1）隐式数据类型转换 （2）显式数据类型转换

    （1）隐式数据类型转换

        python可以自动完成，当两个类型的数据在进行运算的时候，较低的数据类型就会转换成较高数据类型。

#隐式数据类型转换
i=123       #i是整型数据
j=1.23      #j是浮点型数据




k=i+j
print(k)
print(type(k))

运行结果

    （2）显示数据类型转换

    python有他自己的一套数据规则，比如在c语言中字符类型可以转换成整型，但是在python中不可以进行这两者之间的隐式转换。所以和也有一些需要显式强制转换。

x=1
y=int(1.23)         #强制将浮点型转成整型
print(type(x))      #输出x的类型
print(y)            #输出y
print(type(y))      #输出y的类型


x="str1"
y=str(2)            #强制将整型转成字符串
z=str(3.14)         #强制将浮点型转成浮点型
print(type(x))
print(y)            #输出y,已经是字符串类型
print(type(y))
print(z)
print(type(z))

运行结果

一些数据类型转换的内置函数

八.python推导式

是一种特殊的数据处理方式，从一个数据序列构建另一个新的数据序列的结构体。

支持各种数据结构的推导式：

（1）列表（list）推导式. （2）元组（tuple）推导式。（3）集合（set）推导式。（4）字典（dict）推导式

（1）列表推导式

格式：[表达式 for 变量 in 列表 ]   或者 [表达式 for 变量 in 列表 if 条件]

其实就相当于其他语言的for循环了，不过要有一个结构来接收结果

names=['Bob','Tom','Alice','Jerry','Wendy','Smith']

new_names=[name.upper() for name in names if(len(name)>3)]     #返回长度大于3的字符串，转成大写

print(new_names)

运行结果

（3）集合推导式

格式：{ expression for item in Sequence } 或 { expression for item in Sequence if conditional }

set = {i**2 for i in(1,2,3)}    #python用**表示次方形式，i**2是i的平方

print(set)

运行结果

（4）字典推导式

格式：{  键表达式 ：值表达式  for key/value in collection }或  {  键表达式 ：值表达式  for key/value in collection if condition }

names=['Bob','Tom','Alice','Jerry','Wendy','Smith']
newdict={name:len(name) for name in names}    #name->key,len(name)->value，字典要用{}花括号
print(newdict)

运行结果

（5）元组推导式 (生成器表达式)

格式：（ expression for item in Seqence ）或 （ expression for item in Sequence if conditional ）

元组推导可以利用range区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式返回的是一个生成器对象，所以print()输出的时候会出现generator object，使用tuple()函数可以直接将生成器对象转换成元组。

a = (x for x in range(1,10))
print(a)


b = [1,2,3,4,5,6]
c = (x for x in b)
print(c)

运行结果

a = (x for x in range(1,10))
print(a)
a1=tuple(a)    #加一个tuple()函数进行转换
print(a1)


b = [1,2,3,4,5,6]
c = (x for x in b)
print(c)
c1=tuple(c)    #加一个tuple()函数进行转换
print(c1)

运行结果

九.运算符（其他基本都和C一样，就不再赘述）

逻辑运算符：

and 表示与， or 表示或， not表示非

a=10
b=20
print(a and b)  //如果a为false则返回a,否则返回b的值
print(a or b)   //如果a为true,则返回a,否则返回b
print(not a)

运行结果：

成员运算符：

in 在某一集合里

not in 不在，以上两个都返回true/false

#成员运算符
a=[10,20,30,40,50,60]
b=10
c=90
if b in a:
    print("b in a")
else:
    print("b not in a")
if c not in a:
    print("c not in a")
else:
    print("c in a")


i={'a','b','c','d'}
j='a'
k='i'
if j in i:
    print("j in i")
else:
    print("j not in i")
if k not in i:
    print("k not in i")
else:
    print("k in i")

运行结果：

身份运算符：

is 判断是不是引用自同一个对象，相当于id(x)==id(y)

is not 不是引用自同一个对象，返回true/false

#身份运算符
a=10
b=10
c=20
if a is b:
    print("a is b")
else:
    print("a is not b")
if c is not a:
    print("c is not a")
else:
    print("c is a")


a=[10,20]
b={10,20}
print(a is b)       #会返回false，因为一个是列表一个是集合

运行结果：

十.条件控制和循环语句

ps (插一个end关键字):    end关键字可以用于将结果输出到同一行

# 斐波那契数列
a,b= 0,1        #可以多个赋值


while b<100:
    print(b,end=',')    #end用于将结果输出到一行，每次输出以，结尾
    a,b = b,a+b

运行结果

if语句

#if语句
a=10
b=20
if a+b>20:            #每一个条件写完后面要跟：
    print("A")
elif a+b<10:            #python中用elif代替else if
    print("B")
else:                    
    print("C")

运行结果：

（最后会输出A，我就不截屏了）

Python中没有switch case语句

循环语句

（1）while循环

while(条件)：【记得写冒号】

    执行语句

（还是以斐波那契数列为例）

# 斐波那契数列
a,b= 0,1        #可以多个赋值


while b<100:
    print(b,end=',')    #end用于将结果输出到一行，每次输出以，结尾
    a,b = b,a+b

运行结果

while循环还可以用else语句，他作为当while中条件不成立时的执行语句，即结束时最后执行的语句

#还是以斐波那契数列为例
a,b=0,1
while b<100:
    print(b,end=',')
    a,b=b,a+b
else:
    print('b>=100')

运行结果

（2）for语句

for 变量 in 某序列：

    执行语句

else:

    执行语句

a,b=0,1
for i in range(10):        #这个变量是重新定义的，和之前定义的同名变量没有关系，相当于规定循环次数和指针指向
    print(b,end=',')
    a,b=b,a+b
else:
    print('斐波那契数列前10项')

运行结果

names=["Manny","Joe","Alex","Lily","Phil","Clarie"]
for name in names:
    print(name)
else:
    print("end")

运行结果

（3）break,continue语句

大致用法和c语言一样

break语句用法：用来结束循环

n=5
while n>0 :
    n-=1
    if(n==2):
        break
    print(n)

运行结果

continue用法：用来结束当前循环体的执行，进入到下一个循环里

n=5
while n>0 :
    n-=1
    if(n==2):
        continue
    print(n)

运行结果

十一.迭代器和生成器

迭代器：

迭代器是一个可以记住遍历位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

有两个基本方法：iter() 【相当于构造】和 next()【向后遍历】

list=[1,2,3,4]
it = iter(list)  #创建一个迭代器对象（列表）
print(next(it))
print(next(it))

运行结果

迭代器可以用for循环来遍历

list=[1,2,3,4]
it = iter(list)  #创建一个迭代器对象（列表）
for i in it:
    print(i)

运行结果

while语句+next()也可以完成遍历

list=[1,2,3,4]
it = iter(list)  #创建一个迭代器对象（列表）
i=0
while(i<len(list)):
    print(next(it))
    i+=1        #写到这里才意识到python是没有++，--这种运算方式的

运行结果

生成器：

使用了yield的函数被称为生成器，其和普通函数的区别是，生成器是一个返回迭代器的函数，简单点可以说他就是个迭代器。调用生成器函数，返回的是一个迭代器对象。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

import sys


def fibonacci(n):   #生成器函数
    a,b,counter=0,1,1
    while counter<=n :
        yield a     #yield函数，保存当前运行信息
        a,b=b,a+b
        counter +=1
    return          #要有返回值


f=fibonacci(10)     #定义迭代器


while 1:
    try:
        print(next(f),end=',')
    except StopIteration:   #当迭代完成会出现stopiteration异常
        print("end")
        sys.exit()

运行结果

十二.函数

定义格式：

def 函数名（参数列表）：

    函数体

#定义函数
def hello():
    print("hello world!")
#调用
hello()

运行结果

参数传递：

在python中类型属于对象，对象有不同类型的区分，变量没有类型。

string,tuple,number是不可更改的对象，list,dict是可以修改的对象。

不可改变指：a=5,a=10执行的是生成一个int类型的对象10，再让a指向它，而不是改变了a的值，相当于丢弃了5，新生成一个值为10的a

可变指：l=[1,2,3,4]之后给l[2]=5，是直接改变第三个元素的值，不用新生成什么。

在python的函数参数传递：

不可变类型：类似值传递，传递的只是a的值，不会改变a对象本身。

可变类型：类似引用传递，会改变a对象本身

def changeTuple(tup):
    tup=('a','b','c')
    print(tup)


tuple=(1,2,3)
changeTuple(tuple)
print(tuple)


#可变对象
def change(list):
    list.append([1,2,3])
    print(list)


list=[10,20,30]
change(list)
print(list)

运行结果

十三.参数

（1）必需参数：必须以正确顺序传入

（2）关键字参数：可以顺序不一样，用关键字标明

def printinfo(name,age):
    print("名字：",name)
    print("年龄：",age)


printinfo(age=50,name="A")

运行结果

（3）默认参数：在定义的时候参数有默认值，如果在调用函数时，没有传递新参数，就代入默认值执行函数。（和C++一样）

def printinfo(name,age=35):
    print("名字：", name)
    print("年龄：",age)


printinfo("Amy",50)
printinfo("Clraie")

运行结果

（4）不定长参数：需要函数能处理比当初声明时更多的参数。加*星号，会以元组形式导入。加两个星号，会议字典的形式导入。

元组：

def printinfo(arg1,*vartuple):
    print("输出：")
    print(arg1)
    print(vartuple)


printinfo(10)
printinfo(10,20)    
printinfo(10,20,30)

运行结果

字典：

def printinfo(arg1,**vardict):
    print("输出：")
    print(arg1)
    print(vardict)


printinfo(1)
printinfo(1,a=2,b=3)

运行结果

十四.python数据结构

列表：

列表可以修改，字符串和元组不能。

list.append(x) 把一个元素添加到列表结尾。

list.extend(L) 用列表L来扩充列表

list.insert(i,x) 在i位置插入元素x

list.remove(x) 删除值为x的元素

list.pop([i]) 从指定位置移除元素。（[]表示参数是可选的，不是输入[]）

list.clear() 移除列表所有项

list.index(x) 返回值为x的索引

list.sort()给列表排序

list.count(x) 返回x在列表中出现的次数

list.reverse()倒排列表中的元素

list.copy()返回列表的浅复制

列表可以做堆栈用（堆栈特性：先进后出）

stack=[1,2,3]
stack.append(4)
stack.append(5)
print(stack)
stack.pop()
stack.pop()
print(stack)

运行结果

列表也可以做队列用（先进先出）

stack=[1,2,3]
stack.append(4)
stack.append(5)
print(stack)
stack.pop(0)    #pop(0)就相当于出队了
stack.pop(0)
print(stack)

运行结果

del语句

从一个列表中根据索引删除一个元素

 

a=[10,20,3.14,1234]
del a[0]
print(a)

运行结果

各个类型的遍历

#各个类型的遍历
a=[10,20,30,40,50]
for number in a:
    print(number,end=',')
print()
b=('b',20,30,40,'AAA')
for obj in b:
    print(obj,end=',')
print()
c={'c',20,30,40,'BBB'}
for obj in c:
    print(obj,end=',')
print()
#字典遍历
d={'name':'Monica','sex':'female','age':19}
for k,v in d.items():   #关键字和对应的值可以使用items()方法同时解读出来
    print(k,v)
for k,v in enumerate(['name','sex','age']):
    print(k,v)          #通过enumerate（）可以得到索引值和对应值

运行结果

十五.导入模块

（1）

import file  导入名为file的文件，解释器遇到import语句，如果模块在当前的搜索路径就会被导入

搜索路径是一个解释器会先进行所有目录的列表。

from file import f  导入file文件（模块）的f函数。

from file import *导入某个模块的全部内容

（2）

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。

if __name__ == '__main__':

   print('程序自身在运行')

else:

   print('我来自另一模块')

那么以上程序，在本模块中运行会输出'程序自身在运行'，被引用时会运行‘我来自另一模块’

（3）

内置函数dir()可以找到模块内定义的所有名称。以一个字符串列表的形式返回；

#test.py

def fun1():
    print("function1")


a=[10,20,30,40]


def fun2(v):
    print(v)

#main.py

import test


def print_hi(name):
   
    print(f'Hi, {name}')  


if __name__ == '__main__':
    print_hi('PyCharm')
    print(dir(test))

运行结果

(因为建的是一个python项目，所以有一些固定配置，之后输出了，a, fun1,fun2这些自定义的变量以及函数)

（4）包

类似其他语言的包，采用点模块名称，A.B表示一个包A中的B模块，将一个项目分成包主要是为了更清晰地区分，方便开发者。

引用方式和模块引用大同小异。不建议使用 from ... import *方式导入模块，会降低可读性

十六.输出和输入

（1）输出

str.format() 函数格式化输出值，{}花括号中的内容会被format()中的参数替换

>>> print('{}网址： "{}!"'.format('菜鸟教程', 'www.runoob.com'))

菜鸟教程网址： "www.runoob.com!"

在括号中的数字用于指向传入对象在 format() 中的位置

>>> print('{0} 和 {1}'.format('Google', 'Runoob'))

Google 和 Runoob

>>> print('{1} 和 {0}'.format('Google', 'Runoob'))

Runoob 和 Google

如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。

>>> print('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com'))

菜鸟教程网址： www.runoob.com

！a表示使用ascii()，！s表示使用str()函数，！r表示使用repr()

冒号：后面可以跟着字段格式，进行更好的格式化

>>> import math

>>> print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))

常量 PI 的值近似为 3.142。

str()  repr()函数用来实现将变量转成字符串

一般输出使用print()函数，也可以使用文件对象地write()函数

字符串的rjust()函数实现右对齐，ljust()左对齐，center()居中

（2）输入

input()内置函数表示从标准输入读入一行文本，默认读取键盘输入

str = input("请输入：");

print ("你输入的内容是: ", str)

另外文件操作也可以实现（后面再补充）

十七.File 文件

open()方法，用于打开一个文件，并返回文件对象

接受两个参数 即文件名和模式

open(file,mode)

模式一般有t(文本模式)，x(写模式)，b(二进制)，r(只读)，w(只写)

使用open()方法一定要保证关闭文件对象，即调用close()方法。

十八.异常处理

异常捕捉可以使用try/except语句

try-except语句

try:

    执行语句

except:

    发生异常时执行的代码

一个try语句可能包含多个except子句，分别用来处理不同类似的异常。

try-except-else语句

另外还有一个可选else子句，如果使用这个子句，那么必须放在所有except子句之后。

try:

    执行语句

except:

    发生异常时执行的语句

else:

    没有发生异常时执行的语句

try-finally语句

try:

    执行语句

except:

    发生异常时执行的代码

else:

    没有异常时执行的代码

finally:

    不管有没有异常都会执行的代码

抛出异常

raise语句，抛出指定异常，raise[exception ]

x = 10

if x > 5:

    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

那么会抛出异常： Exception : x 不能大于 5 。 x 的值为: 10

如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后被抛出。用于try语句的定义清理行为。

十九.面向对象

类似java 和c++ python设计之初就已经是一门面向对象的语言。

（1）简单实例和构造函数

由于python在定义时就要赋值，所以定义类时就要对所有变量进行初始化。

class myClass:
    name='Sophie'
    def f(self):
        return 'hello world'


x=myClass ()
print(x.name)
print(x.f())

运行结果

__init__()方法为构造方法，可以默认也可以自定义，创建对象时会自动调用__init__()方法。

self代表类的实例，比如上述例子中f(self)，self代表当前类的对象，有点类似this在C++中的用法

类的方法必须要有第一个参数名称，一般都会定义为self

（2）私有变量，继承

一般默认公有变量，变量名前加__两个下划线为私有变量，同时私有方法也用两个下划线开头，外部不能对类的私有变量和方法进行访问

单继承：定义：class  子类名（父类名）：

 

class people:       #类也要加#
    name=''
    age = 0


    _weight=0       #私有变量前加下划线
    def __init__(self,n,a,w):
        self.name=n
        self.age=a
        self._weight=w
    def speak(self):
        print("姓名：",self.name,"年龄：",self.age)


class student(people):      #继承写法，在子类后写（父类）：
    grade=''
    def __init__(self,n,a,w,g):
        #直接调用父类构造函数
        people.__init__(self,n,a,w)
        self.grade=g


    def speak(self):        #覆盖父类同名方法
        print("姓名",self.grade)


s=student('kavien',10,60,3)     #实例化
s.speak()

运行结果

多继承定义：class 子类名（父类1，父类2，父类3……）

 

class people:       #类也要加#
    name=''
    age = 0


    _weight=0       #私有变量前加下划线
    def __init__(self,n,a,w):
        self.name=n
        self.age=a
        self._weight=w
    def speak(self):
        print("姓名：",self.name,"年龄：",self.age)


class student(people):      #继承写法，在子类后写（父类）：
    grade=''
    def __init__(self,n,a,w,g):
        #直接调用父类构造函数
        people.__init__(self,n,a,w)
        self.grade=g


    def speak(self):        #覆盖父类同名方法
        print("姓名",self.name,"年级",self.grade)


class female(people):
    sex='女'
    def __init__(self,n,a,w):
        people.__init__(self,n,a,w)
    def speak(self):
        print("姓名：",self.name,'性别',self.sex)


class sample(student,female):        #同时继承两个父类
    a='sample'
    def __init__(self,n,a,w,g):
        student.__init__(self,n,a,w,g)    
        female.__init__(self,n,a,w)


test = sample("Ally",15,50,9)
test.speak()    #最后调用会默认调用排在前列的父类方法

运行结果