python入门基础-学习笔记
[参考文档]: https://www.runoob.com/python/python-variable-types.html
[推荐文档]: https://blog.csdn.net/hhhhhhhhhhwwwwwwwwww/article/details/120037975
pycharm的一些常用设置
-
进入setting>Editor>File and Code Templates，点击python script，进行设置： """
=================================================
Author : A
Time : ${DATE} ${TIME}
=================================================
"""
-
pycharm中将代码变工整对齐的快捷键：ctrl + alt + L -
在代码前加# 可以注释单行代码，快捷键为Ctrl + / -
第一种 小驼峰式命名法（lower camel case)： 第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog 第二种 大驼峰式命名法（upper camel case）： 每一个单字的首字母都采用大写字母，例如：FirstName、LastName 第三种 用下划线“_”来连接所有的单词，比如send_buf，这是python主推的命名方法，叫做snake-case。
Python 基础语法
-
Python是一个动态类型的语言，可以为变量赋任意类型的值，也可以任意修改变量的值。也就是说，变量的值是什么全取决于你，你给他什么，他就是什么。 -
在Python中所有可以自主命名的内容都属于标识符，比如：变量名，函数名，类名。虽说是自主命名，但也不是想叫什么叫什么，需要遵守标识符规范，如果使用不符合标准的标识符，将会报错SyntaxError: invalid syntax(语法错误) -
标识符规范： 1.标识符中可以含有字母，数字和_，但不能使用数字开头。 2.标识符不能是Python中的关键字和保留字关键字有如下：[‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’,‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’,‘while’, ‘with’, ‘yield’] -
以双下划线开头的 _foo 代表类的私有成员，以双下划线开头和结尾的 foo _ 代表 Python 里特殊方法专用的标识，如 init() __代表类的构造函数。
Python 可以同一行显示多条语句，方法是用分号 ; 分开 -
学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。 -
Python 可以使用引号( ’ )、双引号( " )、三引号( ‘’’ 或 “”" ) 来表示字符串，引号的开始与结束必须是相同类型的。 其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。 -
python中单行注释采用 # 开头。 -
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。 空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。记住：空行也是程序代码的一部分。 -
print输入打印示例 import sys
name = 'Athena';
sys.stdout.write(name);
print(name);
-
多个语句构成代码组 -
缩进相同的一组语句构成一个代码块，我们称之代码组。像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。我们将首行及后面的代码组称为一个子句(clause)。如下实例： if True:
print("True")
else:
print("False")
Python 变量类型
- 变量存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间。基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。
变量赋值
-
Python 中的变量赋值不需要类型声明。 -
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。 -
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。 -
等号 = 用来给变量赋值。等号 = 运算符左边是一个变量名，等号 = 运算符右边是存储在变量中的值。 a=1
b=1.0
c='test'
d="test"
T=true
A = B = C = 100
a1, b1, c1 = 1, 2, "john"
print(type(a))
print(type(b))
print(type(c))
print(type(d))
---------------------------------
<class 'int'>
<class 'float'>
<class 'str'>
<class 'str'>
五个标准的数据类型
-
Numbers（数字） -
String（字符串） -
List（列表） -
Tuple（元组） -
Dictionary（字典） (备注：此处暂时还不理解)
Python中的运算符
-
1、算术运算符：加+ 减- 乘* 除/ 取余% 幂运算** 商取整// a=10;b=20;
print('加：',a+b);print('减：',a-b); print('乘：',a*b); print('除：',a/b); print('取余：',a%b)
print('幂运算：',a**b); print('商取整：',a//b)
-
2、赋值运算符：= += -= *= /= %= -
a = 1
print('a=：', a)
a+=100
print('a+=：', a)
a-=100
print('a-=：', a)
a*=100
print('a*=：', a)
a/=100
print('a/=：', a)
a%=100
print('a%=：', a)
-
3、比较运算符：== > < >= <= != print(a,b,)
print('a>b？', a>b )
print('a<b？', a<b )
print('a>=b？', a>=b)
print('a<=b？', a<=b)
print('a!=b？', a!=b)
-
4、逻辑运算符：and —>一假为假 or —>一真为真 not —>取反 a = 1
b = 2
c = 3
print(a<b and a<c)
print(a>a or a<b)
print(not a==a )
-
5、成员运算符：in 、 not in str = "测试同学"
a = "测" in str
b = "测" not in str
print(a,b)
-
6、身份运算符：is 、 is not var1 = 100
var2 = 100
t1 = var1 is var2
t2= var1 is not var2
print(t1)
print(t2)
-
is 与 == 区别：is 用于判断两个变量引用对象是否为同一个(同一块内存空间)， == 用于判断引用变量的值是否相等。
Python 字符串
-
字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。创建字符串很简单，只要为变量分配一个值即可。 -
1、字符串赋值： str1='1'; str2="1"
str3=""" test
Athena 可直接换行"""
str4=''' test
可直接换行'''
a="'aaaa'"
-
2、字符串拼接： a='你好'
b="测试同学"
c="""A
"""
d='''B'''
p=a+b+c+d;
print(p);
你好测试同学A
B
-
3、下标取值：
str='0123456789'
print(str)
print(str[0])
print(str[9])
print(str[-1])
print(str[-10])
print(str[0:10])
print(str[0:10:2])
print(str[0:10:2])
print(str[-10:-5:2])
-
4、python字符常用的方法
str='Atheea'
print(str.find('h'))
print(str.find('e'))
print(str.find('S'))
str='Atheea'
print(str.count('A'))
print(str.count('e'))
str='AtheeaAth'
print(str.replace('Ath','XYZ',1))
print(str.replace('Ath','XYZ'))
str='123456789054321'
print(str.split('5'))
print(str.split('5',1))
str1='abcd';str2='ABCD'
print(str1.upper())
print(str2.lower())
str="操作人员：{},年龄：{}"
name=input("你好，输入姓名：")
age=input("你好，输入年龄：")
print(str.format(name,age));
----------------
你好，输入姓名：Athena
你好，输入年龄：20
操作人员：Athena,年龄：20
str1 = "我的名字：{}，年龄：{}，性别：{}。".format("Athena","18","nv")
print(str1)
str2 = "我的名字：{2}，年龄：{0}，性别：{1}。".format("20","nv","Athena")
print(str2)
str4 = "我的名字：{a}，年龄：{b}，性别：{c}。".format(b = "20",a = "Athena",c = "nv")
print(str4)
str5= "我的名字：{a}，年龄：{b}，性别：{c}。".format(a = "Athena",c = "nv",b = "18")
print(str5)
-
5、字符串的转义
print('It is\na Wonderful Life')
print('It is\ta Wonderful Life')
print('D:\\Program Files\\study')
print(r'D:\Program Files\study')
print(R'D:\Program Files\study')
python数据类型的转换
Python 列表(List)
-
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。 -
Python有6个序列的内置类型，但最常见的是列表和元组。 -
序列都可以进行的操作包括索引，切片，加，乘，检查成员。 -
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。 -
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。 -
列表的数据项不需要具有相同的类型 -
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。 list1 = ['Athena', 'test', 100, 10.2]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list3 = ["a", "b", "c", "d"]
list3.pop()
print(list3)
list3.pop(0)
print(list3)
list4 = ['a', 'b', 1, 2]
list4.insert(0, '_a')
print(list4)
list4.extend([11, 22, 33])
print(list4)
list4.remove('a')
list4.remove(11)
print(list4)
list4.clear()
print(list4)
list5 = [1, 2, 3, 4, 5, 1]
print(list5.index(1))
print(list5.count(1))
list5[0] = 'a'
print(list5)
list6 = [6, 2, 3, 4, 5, 1, 0]
list6.sort()
print(list6)
list6.reverse()
print(list6)
list7 = list6.copy()
print(list7)
print(list7, id(list7))
python元组
-
Python的元组与列表类似，不同之处在于元组的元素不能修改。 -
元组使用小括号，列表使用方括号。 -
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5)
tup3 = "a", "b", "c", "d"
print(type(tup1))
print(type(tup2))
print(type(tup3))
tup0= ()
print(tup0)
tup4 = (1)
tup5 = (1,)
print(type(tup4))
print(type(tup5))
tu6 = ("a", 1, 2, 3, 4, 5)
print(tu6[0], tu6[5])
print(tu6[0:6])
tu7 = ('11', '22')
print(tu7)
print(list(tu7))
print(tu6.index("a"), tu6.index(3))
tu8 = ("Athena", "", 1, "1", "2", "3", "1")
print(tu8.count("1"))
python数据类型的可变/不可变
-
数据类型的可变不可变
a = 5
print(id(a))
a = a + 2
print(id(a))
str1 = '123abc'
print(id(str1))
str1 = str1.replace('1', '11')
print(id(str1))
li0 = [11, 22, 33]
print(id(li0))
li0.append(44)
print(id(li0))
Python 字典(Dictionary)
-
字典是另一种可变容器模型，且可存储任意类型对象。 -
字典的定义：使用{}来表示字典，每一个元素都是由一个键值对（key:value)组成
user_info_1 = {'name': 'Athena', 'age': 23, '性别': 'nv'}
print(user_info_1, type(user_info_1))
user_info_2 = dict(name='Athena', age=18, 性别='nv')
print(user_info_2, type(user_info_2))
data1 = [('name', 'Athena'), ('age', 20), ('性别', 'nv')]
user_info_3 = dict(data1)
print(user_info_3,type(user_info_3))
user_info = {"name": "Athena", "age": 20, "性别": "nv"}
name = user_info['name']
print(name)
print(user_info['age'])
dic1 = {'a': 11, 'a': 111, 'a': 1111}
dic2 = {'a': 11, 'b': 111, 'c': 1111}
print(dic1)
print(dic2)
dic = {'a': 11, 'b': 22, 'c': 33}
dic['d'] = 44
print(dic)
dic.update({'f': 55, 'k': 66})
print(dic)
dic['a'] = 100
print(dic)
dic1 = {"张三": 24, "李四": 23, "王五": 25, "赵六": 27}
del dic1["张三"]
print(dic1)
print(dic1.pop("李四"))
print(dic1)
dic1.popitem()
print(dic1)
a = dic['a']
print(a)
b = dic.get('a')
print(b)
c = dic.get('Z')
print(c)
dic3 = {'a': 11, 'b': 22, 'c': '33'}
res3 = dic.keys()
res4 = list(dic.keys())
print(res3, type(res3))
print(res4, type(res3))
dic5 = {'a': 11, 'b': 22, 'c': '33'}
res5 = dic3.values()
res6 = list(dic3.values())
print(res5, type(dic5))
print(res6, type(dic5))
dic7 = {'a': 11, 'b': 22, 'c': '33'}
res7 = dic.items()
res8 = list(dic.items())
print(res7, type(dic7))
print(res8, type(dic7))
a = 10
del a
list1 = [1, 2, 3]
del list1[0]
print(list1)
dic1 = {'a': 11, 'b': 22, 'c': '33'}
del dic1['a']
print(dic1)
Python 日期和时间
-
Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。 -
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。 -
时间间隔是以秒为单位的浮点小数。 -
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。 -
Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳。
import time
ticks = time.time()
print("当前时间戳为:", ticks)
localtime1 = time.localtime(time.time())
print("本地时间为 :", localtime1)
localtime2 = time.asctime(time.localtime(time.time()))
print("本地时间为 :", localtime2)
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))
a = "Thu Sep 02 15:53:04 2021"
print(time.mktime(time.strptime(a, "%a %b %d %H:%M:%S %Y")))
import calendar
cal = calendar.month(2021, 9)
print("以下输出2016年1月份的日历:"+cal)
'''
以下输出2016年1月份的日历: September 2021
Mo Tu We Th Fr Sa Su
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
'''
Python 条件循环流程
-
控制流程
n = input("请输入1或2")
if n==1:
print("输入数字=1")
else:
print("输入数字！=1")
n = 3
if n > 1:
print(">1")
elif n >2 :
print(">2")
else:
print("等于0")
-
while循环 i = 0
while i < 100:
i = i + 1
print("这是第{}遍打印：hello".format(i))
while True:
print("hello python")
i = 0
while i < 100:
print("这是第{}遍打印：hello python".format(i))
-
break的作用
i = 0
while i < 100:
i = i + 1
print("这是第{}遍打印：hello".format(i))
if i == 5:
break
print("end")
print("---------循环体之外的代码-------------")
-
continue的作用
i = 0
while i < 10:
i = i + 1
print("这是第{}遍打印：hello".format(i))
if i == 5:
continue
print("end")
print("---------循环体之外的代码-------------")
-
for循环
print(list(range(10)))
print(list(range(1, 10)))
print(list(range(1, 52, 5)))
s = 0
for i in range(1, 11):
s = s + i
print(s)
print(s)
i = 1
s = 0
while i <= 10:
s = s + i
i += 1
print(s)
print(s)
-
for循环的应用场景 遍历列表、 遍历字符串 、遍历字典、 遍历元组
str1 = 'Athena'
for i in str1:
print(i)
tu1 = (1, 2, 3, 4, 5)
for i in tu1:
print(i)
list1 = [11, 22, 33, 44]
for i in list1:
print(i)
dic1 = {"AA": "BB", 88: 99}
for i in dic1:
print(i)
for i in dic1.values():
print(i)
for i in dic1.items():
print(i)
for k, v in dic1.items():
print("key:", k)
print("value:", v)
Python 函数
-
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。 -
你可以定义一个由自己想要功能的函数，以下是简单的规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号**()**。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
-
内置函数
-
自定封装函数 def num( str ):
str1=str+5
return str1
-
函数的调用：函数名（）
def num(st):
str1 = st + 5
return str1
print(num(3))
def func():
for i in range(1, 5):
print()
for j in range(1, i + 1):
print('* ', end="")
func()
def ff(n):
if n == 1:
return n + 1
else:
return n - 1
print(ff(1))
-
函数的参数
def func(a, b):
print("a的值：{}".format(a))
print("b的值：{}".format(b))
return a + b
res = func(11, 88)
def func(a, b=10, name="Athena"):
print("a的值：{}".format(a))
print("b的值：{}".format(b))
print("name的值:{}".format(name))
return a, b, name
print(func(1))
print(func(1, 2, 'Athena'))
def func(a, b=111, *args):
print("a的值：{}".format(a))
print("b的值：{}".format(b))
print("ppp的值：{}".format(args))
return a, b, args
pass
print(func(1, 2, 3, 4, 5))
def func(a, b=99, **kwargs):
return a, b, kwargs
print(func(a=11, b=22, c=333, d=999))
python变量作用域
-
变量作用域：一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域:全局变量\局部变量
name = 'lyj'
def tefun():
a='lyj'
print(name)
a = 100
print(a)
print(id(a))
def func():
global a, b
a = 101
b = 102
print(id(a))
func()
print(id(a))
python-内置函数
-
常用函数
a = -88, 2, 3, 4, 700
li = [0, 3, 10000]
st = (-1, 3, 500)
print(max(a))
print(max(li))
print(max(st))
print(max(1, 2, 3))
print(min(a))
print(min(li))
print(min(st))
print(min(1, 2, 3))
print(sum(st))
li1 = (11, 22, 331, 21, 322)
dic = {"a": 11, "b": 333}
li1s = enumerate(li1)
dics = enumerate(dic)
print(li1s)
print(dics)
for i in li1s:
print(i)
for i in dics:
print(i)
str1 = "{'a':11,'b':22}"
dic1 = eval(str1)
str2 = "[11,22,33,44]"
list1 = eval(str2)
print(dic1, type(dic1))
print(list1, type(list1))
li = [1, 2, 3, 4, 5, 6]
li2 = [11, 22, 33, 44, 55, 66]
li3 = [111, 222, 333, 444, 555, 666, ]
res = zip(li, li2, li3)
print(list(res))
title = ["aa", "bb", "cc"]
value = [11, 22, 33]
res1 = zip(title, value)
print(dict(res1))
print(list(res1))
def func(a):
print("参数a", a)
return a<12
li = [11, 22, 33, 44, 111, 222, 222,10]
res = filter(func, li)
print(res)
print(list(res))
Python 基本的 I/O 函数
-
Python操作文件
fi1 = open(r"D:\Program Files\work_project\test1\list_1.py", "r", encoding="utf8")
fi2 = open(r"list_1.py", "r", encoding="utf8")
content = fi2.read()
print("文件中读取出来的内容为：", content)
fi2.close()
fo = open("foo.txt", "w",encoding="utf8")
fo.write("TEST")
fo.close()
f11 = open("foo.txt", "r", encoding="utf8")
content1 = f11.readline()
print(content1)
content2 = f11.readline()
print(content2)
content3 = f11.readline()
print(content3)
f11.close()
f22 = open("foo.txt", "r", encoding="utf8")
content22 = f22.readlines()
print(content22)
f22.close()
with open("foo.txt", "r", encoding="utf8") as f:
content = f.read()
print(content)
Python 面向对象
Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。
-
面向对象技术简介： -
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 -
**类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。 -
**数据成员：**类变量或者实例变量, 用于处理类及其实例对象的相关的数据。 -
**方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。 -
**局部变量：**定义在方法中的变量，只作用于当前实例的类。 -
**实例变量：**在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。 -
**继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。 -
**实例化：**创建一个类的实例，类的具体对象。 -
**方法：**类中定义的函数。 -
**对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。 -
import 导入模块：
from base import a
a()
from base import A
print(A)
from base import a as a_1
a_1()
from base import A as A_1
print(A_1)
-
定义类\创建对象
- 第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
- self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
- 在Python中定义类经常会用到__init__函数（方法），首先需要理解的是，两个下划线开头的函数是声明该属性为私有，不能在类的外部被使用或访问。而__init__函数（方法）支持带参数类的初始化，也可为声明该类的属性（类中的变量）。__init__函数（方法）的第一个参数必须为self，后续参数为自己定义。
class Employee:
empCount = 0
def __init__(self, name2, age):
self.name = name2
self.age = age
Employee.empCount += 1
def displayCount(self):
print("Total Employee %d" % Employee.empCount)
def displayEmployee(self):
print( "Name : ", self.name, ", age: ", self.age)
emp1 = Employee('Athena',20)
print(emp1.name,emp1.age)
print(id(emp1))
emp2 = Employee('Athena1',21)
print(emp2.name,emp2.age)
print(Employee.empCount)
print(id(emp2))
emp3 = Employee('Athena1',21)
print(id(emp3))
emp1.displayEmployee()
emp1.displayCount()
Python之类的继承
-
虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法 -
子类在继承的时候，在定义类时，小括号()中为父类的名字 -
父类的属性、方法，会被继承给子类
class A(object):
A1 = 1
def __init__(self,ax):
self.ax=ax
print("TEST")
pass
def A2(self):
print("父类的方法")
class a(A):
def a1(self, newName):
self.name = newName
def a2(self):
print("子类方法")
x1 = a(222)
-
私有属性和方法的继承 class Animal():
def __init__(self, name='动物', color='白色'):
self.__name = name
self.color = color
def __test(self):
print(self.__name)
print(self.color)
def __aa(self):
print("私有方法")
def test(self):
print(self.__name)
print(self.color)
self.__aa()
class Dog(Animal):
def dogTest1(self):
print(self.color)
def dogTest2(self):
self.test()
an1 = Animal()
an2 = Animal(1,2)
an1.test()
an2.test()
A = Animal()
print(A.color)
A.test()
D1 = Dog("小狗", color="黄")
D2 = Dog(name="小花狗", color="黄色")
D1.dogTest1()
D1.dogTest2()
D2.dogTest1()
D2.dogTest2()
-
Python中多继承 class A:
def setA(self):
print("setA")
def xx(self):
print("xx--A")
class B:
def setB(self):
print("setB")
def xx(self):
print("xx--B")
class C(A,B):
def setC(self):
print("setC")
obj_c = C()
obj_c.setA()
obj_c.setB()
obj_c.setC()
obj_c.xx()
print("搜索顺序：",C.__mro__)
-
重写父类方法 class A:
def printA(self):
print('----A----')
class B(A):
def printA(self):
print('----B----')
x=B()
x.printA()
python静态方法和类方法
- 类方法是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法
- 类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以’cls’作为第一个参数的名字，就最好用’cls’了），能够通过实例对象和类对象去访问。
- 类方法还有一个用途就是可以对类属性进行修改
- 静态方法需要通过修饰器
@staticmethod来进行修饰，静态方法不需要多定义参数 - 类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法
- 实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用
|