Python
输出（打印）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| print(520)
print(114514)
print('helloworld')
fp = open('D:/text.txt', 'a+')
print('hello world', file=fp)
fp.close()
name = '玛利亚'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)
n1=10086
n2=114514
n3=123
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
|
转义字符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
print('hello\nworld')
print('hello\tworld')
print('hellooo\tworld')
print('hello\rworld')
print('hello\bworld')
print('http:\\\\www.baidu.com')
print('老师说:\'大家好\'')
print(r'hello\nworld')
|
类型转换
1
2
3
4
| name = '张三'
age = 20
print('我叫'+name+'今年'+str(age)+'岁')
|
1
2
3
4
5
|
present = input('小志想要什么礼物呢')
print(present,type(present))
|
1
2
3
4
5
|
a = int(input('请输入一个加数'))
b = int(input('请输入另一个加数'))
print(a+b)
|
算数运算符
1
2
3
4
5
6
7
8
9
10
11
12
13
| print(1+1)
print(1-1)
print(2*4)
print(1/2)
print(11//2)
print(9//-4)
print(-9//4)
print(11%2)
print(9%-4)
print(-9%4)
print(2**3)
|
比较运算符
1
2
3
4
5
6
7
8
|
a,b=10,20
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)
print('a!=b吗',a!=b)
|
多分支结构
1
2
3
4
5
6
7
8
9
10
11
12
| score = int(input('请输入一个成绩:'))
if 90<=score<=100:
print('A级')
elif 80<=score<=89:
print('B级')
elif 70<=score<=79:
print('C级')
elif 0<=score<=69:
print('芜湖！给我狠狠的挂科！')
else:
print('好死！')
|
range函数的使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| r = range(10)
print(r)
print(list(r))
r = range(1,10)
print(r)
print(list(r))
r = range(1,10,2)
print(r)
print(list(r))
print(10 in r)
print(9 in r)
|
for _ in循环
1
2
3
4
5
6
7
8
9
10
11
| for item in ('python'):
print(item)
for i in range(10):
print(i)
for _ in range(5):
print('这技术爱谁学谁学吧，老子不干了，开摆！')
|
else语句
if … else 是if条件表达式不成立时执行else
while …else 和for …else是没有碰到break时执行
列表
列表是可变序列，可以向列表中添加元素，而列表的内存地址不变
1.创建列表的第一种方式，使用 [ ]
1
2
3
4
5
6
|
lst=['好想摆烂','怎么一直在睡觉','为什么一定要去打暑假工','是嫌弃以后的打工时间不够长？']
print(lst)
print(lst[0])
print(lst[-1])
print(lst[0],lst[2])
|
2.创建列表的第二种方式，使用内置函数 list()
1
2
3
4
5
6
7
8
9
|
lst2=list(['好想摆烂','怎么一直在睡觉','为什么一定要去打暑假工','是嫌弃以后的打工时间不够长？'])
print(lst)
print(lst[0])
print(lst[-1])
print(lst[0],lst[2])
print(lst.index('好想摆烂'))
print(lst.index('为什么一定要去打暑假工',0,4))
|
获取列表中的多个元素，切片操作
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
| lst=[10,20,30,40,50,60,70,80]
print('原列表',lst)
lst2=lst[1:6:1]
print('截取的片段,步长为1',lst2)
lst3=lst[1:6:2]
print('截取的片段,步长为2',lst3)
lst4=lst[1:6:]
print('截取的片段,没写step，默认为1',lst4)
lst5=lst[:6:2]
print('截取的片段,没写start，默认为0',lst5)
lst6=lst[1::2]
print('截取的片段,没写stop，默认为最大',lst6)
print('------------------------step为负数的情况----------------------------')
print('原列表',lst)
print('step=-1',lst[::-1])
print(lst[6:0:-2])
|
列表元素的判断以及遍历
1
2
3
4
5
6
7
8
|
lst=[10,20,30,40,50,60,70,80]
print(10 in lst)
print(10086 in lst)
for item in lst:
print(item)
|
列表元素的增删改查
增
append
1
2
3
4
5
6
7
| lst=[10,20,30]
lst.append(10086)
print('append 添加元素后',lst)
lst2=['hello','world']
lst.append(lst2)
print('append 把列表当成是一个元素',lst)
|
添加元素前 [10, 20, 30]
append 添加元素后 [10, 20, 30, 10086]
append 把列表当成是一个元素 [10, 20, 30, 10086, [‘hello’, ‘world’]]
extend
1
2
3
4
|
lst=[10,20,30]
lst.extend(lst2)
print('extend 向末尾添加多位元素',lst)
|
extend 向末尾添加多位元素 [10, 20, 30, ‘hello’, ‘world’]
insert
1
2
3
|
lst=[10,20,30]
lst.insert(1,114514)
|
insert 在任意地方添加一个元素 [10, 114514, 20, 30]
切片
1
2
3
4
5
6
|
lst=[10,20,30]
lst3=['true','false']
lst[1:]=lst3
print('切片 在任意的位置上添加n多个元素',lst)
|
切片 在任意的位置上添加n多个元素 [10, ‘true’, ‘false’]
删
remove
1
2
3
4
5
6
| lst=[10,20,30,40,50,60,30]
print('原列表',lst)
lst.remove(30)
print('使用remove删除30',lst)
|
原列表 [10, 20, 30, 40, 50, 60, 30]
使用remove删除30 [10, 20, 40, 50, 60, 30]
pop
1
2
3
4
5
6
7
8
9
10
11
12
| lst=[10,20,30,40,50,60,30]
print('原列表',lst)
lst.pop(1)
print('使用pop删除索引位置为1的数',lst)
lst=[10,20,30,40,50,60,30]
print('原列表',lst)
lst.pop()
print('没有指定pop的参数（索引）',lst)
|
原列表 [10, 20, 30, 40, 50, 60, 30]
使用pop删除索引位置为1的数 [10, 30, 40, 50, 60, 30]
原列表 [10, 20, 30, 40, 50, 60, 30]
没有指定pop的参数（索引） [10, 20, 30, 40, 50, 60]
切片
1
2
3
4
5
6
7
8
9
10
|
lst2=lst[1:3]
print('采用切片操作',lst2)
lst=[10,20,30,40,50,60,30]
print('原列表',lst)
lst[1:3]=[]
print('切片操作的第二种',lst)
|
采用切片操作 [20, 30]
原列表 [10, 20, 30, 40, 50, 60, 30]
切片操作的第二种 [10, 40, 50, 60, 30]
clear
[ ]
del
NameError: name ‘lst’ is not defined.
改
1
2
3
4
|
lst=[10,20,30,40]
lst[1:3]=[300,400,500]
print(lst)
|
查
1
2
3
4
5
6
7
8
|
lst=[10,20,30,40,50,60,70,80]
print(10 in lst)
print(10086 in lst)
for item in lst:
print(item)
|
列表元素的排序操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
lst=[20,40,66,33,78,96]
print('排序前的列表',lst)
lst.sort()
print('排序后的列表',lst)
lst.sort(reverse=True)
print('降序排序',lst)
lst.sort(reverse=False)
print('升序排序',lst)
print('---------------使用内置函数sort()对列表进行排序将产生一个新的列表对象--------------')
lst=[3,1,2,9,5,8,4,6,7]
new_list=sorted(lst)
print('原列表',lst)
print('新列表',new_list)
desc_list=sorted(lst,reverse=True)
print('降序排序',desc_list)
|
列表生成式
1
2
3
4
5
6
|
lst=[i for i in range(1,10)]
print(lst)
lst=[i*i for i in range(1,10)]
print(lst)
|
字典
字典的创建方式
1.使用{ }来创建字典
1
2
3
|
scores={'张三':100,'李四':98,'王五':45}
print(scores)
|
2.第二种创建dict
1
2
3
|
student=dict(name='jack',age=20)
print(student)
|
获取字典的元素
1
2
3
4
5
6
7
8
9
|
scores={'张三':100,'李四':98,'王五':45}
print(scores['张三'])
print(scores.get('张三'))
print(scores.get('桑你忒他'))
print(scores.get('模拟穹',99))
|
字典元素的增删改操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
scores={'张三':100,'李四':98,'王五':45}
print('张三' in scores)
print('张三' not in scores)
del scores['张三']
scores.clear()
print(scores)
scores['雷军']=98
print(scores)
scores['雷军']=10086
print(scores)
|
获取字典的视图
keys() 获取所有的key
1
2
3
4
| scores={'张三':100,'李四':98,'王五':45}
keys=scores.keys()
print(keys)
print(list(keys))
|
values() 获取所有的values
1
2
3
|
values=scores.values()
print(values)
|
items() 获取所有的key-value对
1
2
3
|
items=scores.items()
print(items)
|
字典元素的遍历
1
2
3
4
5
|
for items in scores:
print(items,scores[items],scores.get(items))
|
字典的特点
1
2
3
4
5
6
7
8
9
|
d={'name':'张三','name':'李四'}
print(d)
d={'name':'张三','nikname':'张三'}
print(d)
|
字典生成式
内置函数zip()
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元祖，然后返回这些 元组 组成的 列表
1
2
3
4
5
6
7
8
9
10
11
12
13
| items=['fruits','books','others']
prices=[96,78,85]
d={single_item:single_price for single_item,single_price in zip(items,prices)}
print(d)
d={single_item.upper():single_price for single_item,single_price in zip(items,prices)}
print(d)
|
元组
Python内置的数据结构之一，是一个不可变序列，不允许修改元素
不可变序列和可变序列
不可变序列：字符串，元组 没有 增删改 操作
可变序列：列表，字典 可以对序列执行 增删改 操作，对象地址不发生改变
元组的创建方式
1.第一种创建方式，使用()
1
2
3
4
5
6
7
8
9
|
t=('python','hello',10086)
print(t)
print(type(t))
t1='python','hello',10086
print(t1)
print(type(t1))
|
2.第二种创建方式，使用内置函数tuple()
1
2
3
4
|
t2=tuple(('python','hello',10086))
print(t2)
print(type(t2))
|
元组的核心判定：逗号
1
2
3
4
5
6
7
8
9
|
t3='python',
print(t3)
print(type(t3))
t4='python'
print(t4)
print(type(t4))
|
元组的遍历
1
2
3
4
5
6
7
|
t=('python','hello',10086)
for item in t:
print(item)
'''python
hello
10086'''
|
集合
1.第一种创建方式使用{ }
1
2
3
|
s={1,2,2,7,4,4,7}
print(s)
|
2.第二种创建方式使用set()
1
2
3
|
s1=set(range(6))
print(s1,type(s1))
|
集合当中的元素不允许重复
1
2
3
|
s2=set([1,2,2,7,4,4,7])
print(s2,type(s2))
|
集合中的元素是无序的
1
2
3
4
5
6
|
s3=set((1,2,4,4,5,65,10086))
print(s3,type(s3))
s4=set('python')
print(s4,type(s4))
|
定义空集合
1
2
3
4
5
6
7
|
s5=set()
print(s5,type(s5))
s6={}
print(s6,type(s6))
|
集合元素的判断操作
1
2
3
4
5
|
s={1,10,123,10086}
print(1 in s)
print(1919810 in s)
print(114514 in s)
|
集合元素的新增操作
add
1
2
3
4
5
|
s={1,10,123,10086}
s.add(80)
print(s)
|
update
1
2
3
4
5
6
|
s.update({200,300,400})
print(s)
s.update([369,589,99])
s.update((147,56,76))
print(s)
|
集合元素的删除操作
remove
调用remove()，一次删除一个指定元素，如果指定的元素不存在就抛出异常KeyError
1
2
3
4
5
|
s.remove(200)
print(s)
|
discard
调用discard(),一次删除一个指定元素，如果指定的元素不存在也不抛异常
1
2
3
4
5
6
|
s.discard(10086)
print(s)
s.discard(10087)
print(s)
|
pop
调用pop()，一次只删除一个元素,删除最左边的元素，pop不能指定参数
1
2
3
4
5
6
7
|
s.pop()
print(s)
s.pop()
print(s)
|
clear
clear()清空所有的元素
集合间的关系
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
|
s1={1,2,3,4}
s2={4,3,2,1}
print(s1==s2)
print(s1!=s2)
s1={1,2,3,4,5,6}
s2={4,3,2,1}
s3={1,2,9}
print(s2.issubset(s1))
print(s3.issubset(s1))
print(s1.issuperset(s2))
print(s1.issuperset(s3))
print(s2.isdisjoint(s3))
s4={100,200,300}
print(s2.isdisjoint(s4))
|
集合的数据操作
交集
1
2
3
|
print(s1.intersection(s2))
print(s1 & s2)
|
并集
1
2
3
|
print(s1.union(s2))
print(s1|s2)
|
差集
1
2
3
|
print(s1.difference(s2))
print(s1-s2)
|
对称差集
1
2
3
|
print(s1.symmetric_difference(s2))
print(s1^s2)
|
集合生成式
1
2
3
|
s={i*i for i in range(10)}
print(s)
|
列表，元组，字典，集合总结
字符串
字符串的查询操作的方法
1
2
3
4
5
| s='hello,hello'
print(s.index('lo'))
print(s.find('lo'))
print(s.rindex('lo'))
print(s.rfind('lo'))
|
字符串的大小写转换操作的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
| s='hello,python'
a=s.upper()
print(a,id(a))
print(s,id(s))
b=s.lower()
print(b,id(b))
print(s,id(s))
print(b==s)
print(b is s)
s2='hello,python'
print(s2.swapcase())
print(s2.title())
|
字符串内容对齐操作的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| s='hello,python'
print('居中对齐')
print(s.center(20,'*'))
print('左对齐')
print(s.ljust(20,'*'))
print(s.ljust(10))
print(s.ljust(20))
print('右对齐')
print(s.rjust(20,'*'))
print(s.rjust(10))
print(s.rjust(20))
|
字符串劈分操作的方法
1
2
3
4
5
6
7
8
9
10
11
12
| s='hello world python'
lst=s.split()
print(lst)
s1='hello|world|python'
print(s1.split(sep='|'))
print(s1.split(sep='|',maxsplit=1))
print('rsplit从右侧开始劈分')
print(s.rsplit())
print(s1.rsplit('|'))
print(s1.rsplit(sep='|',maxsplit=1))
|
判断字符串操作的方法
1
2
3
4
5
6
7
| s='hello,python'
print('1.',s.isidentifier())
print('2.','hello'.isidentifier())
print('3.','张三_'.isidentifier())
print('4.','张三_123'.isidentifier())
print('5.','\t'.isspace())
|
字符串操作的其他方法
1
2
3
4
5
6
7
8
9
10
11
12
| s='hello,python'
print(s.replace('python','嗨嗨嗨'))
s1='hello,python,python,python'
print(s1.replace('python','嗨嗨嗨',2))
lst=['hello','嗨嗨嗨','python']
print('|'.join(lst))
print(''.join(lst))
t=('hello','嗨嗨嗨','python')
print(''.join(t))
print('*'.join('python'))
|
字符串的比较操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| print('apple'>'app')
print('apple'>'banana')
print(ord('a'),ord('b'))
print(chr(97),chr(98))
a=b='python'
c='python'
print(a==b)
print(b==c)
print(a is b)
print(b is c)
|
字符串的切片操作
1
2
3
4
5
6
7
8
9
10
11
12
13
| s='hello,python'
s1=s[:5]
s2=s[6:]
s3='!'
newstr=s1+s3+s2
print(s1)
print(s2)
print(newstr)
print('完整写法')
print('-------------切片[start:end:step]--------------')
print(s[1:5: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
|
name='张三'
age=20
print('我叫%s，今年%d岁'%(name,age))
print('我叫{0}，今年{1}岁'.format(name,age))
print(f'我叫{name},今年{age}岁')
print('%10d'%99)
print('%f'%3.1415926)
print('%.3f'%3.1415926)
print('%10.3f'%3.1415926)
print('hellohello')
print('{0}'.format(3.1415926))
print('{:.3f}'.format(3.1415926))
print('{:10.3f}'.format(3.1415926))
'''
我叫张三，今年20岁
我叫张三，今年20岁
我叫张三,今年20岁
99
3.141593
3.142
3.142
hellohello
3.1415926
3.142
3.142
进程已结束,退出代码0
'''
|
字符串的编码和解码
1
2
3
4
5
6
7
8
9
10
11
12
| s='天涯共此时'
print(s.encode(encoding='GBK'))
print(s.encode(encoding='UTF-8'))
bytes=s.encode(encoding='GBK')
print(bytes.decode(encoding='GBK'))
bytes=s.encode(encoding='UTF-8')
print(bytes.decode(encoding='UTF-8'))
|
函数
函数的创建
1
2
3
4
5
6
| def calc(a,b):
c=a+b
return c
result=calc(10,20)
print(result)
|
函数的参数传递
1
2
3
4
5
6
7
8
9
| def calc(a,b):
c=a+b
return c
result=calc(10,20)
print(result)
res=calc(b=10,a=20)
print(res)
|
函数的返回值
函数的参数定义
默认值参数
个数可变的位置参数_个数可变的关键字形参
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
| def fun(*arg):
print(arg)
fun(10)
fun(10,20)
fun(10,20,30)
def fun1(**arg):
print(arg)
fun1(a=10)
fun1(a=10,b=20)
fun1(a=10,b=20,c=30)
def fun2(*arg,**a):
pass
'''
def fun2(*arg,*a):
pass
以上代码，程序会报错，个数可变的位置参数只能是1个
def fun3(**arg,**a):
pass
以上代码，程序会报错，个数可变的关键字参数只能是1个
def fun4(**arg,**a):
pass
在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，
要求，个数可变的位置形参，放在个数可变的关键字形参之前
'''
|
函数的参数总结
1
2
3
4
5
6
7
8
9
10
11
12
| def fun(a,b,c):
print('a=',a)
print('b=',b)
print('c=',c)
fun(10,20,30)
lst=[11,22,33]
fun(*lst)
fun(a=100,c=300,b=200)
fun(**dic)
|
变量的作用域
递归函数
斐波那契数列
Python的异常处理机制
多个except结构
try…except…else结构
try…except…else…finally结构
python常见的异常类型
traceback模块
类的创建
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| class Student:
native_pace='浙江'
def __init__(self, name, age):
self.name=name
self.age=age
def eat(self):
print('学生在吃饭...')
@staticmethod
def method():
print('我使用了staticmethod，进行修试，所以我是静态方法')
@classmethod
def cm(cls):
print('我是类方法，因为我使用了classmethod进行修饰')
def drink():
print('喝水')
|
类属性，类方法，静态方法
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
| class Student:
native_pace='浙江'
def __init__(self, name, age):
self.name=name
self.age=age
def eat(self):
print('学生在吃饭...')
@staticmethod
def method():
print('我使用了staticmethod，进行修饰，所以我是静态方法')
@classmethod
def cm(cls):
print('我是类方法，因为我使用了classmethod进行修饰')
def drink():
print('喝水')
stu1=Student('张三',20)
stu1.eat()
print(id(stu1))
print(type(stu1))
print(stu1)
print('----------------------------')
Student.eat(stu1)
stu1=Student('张三',20)
stu2=Student('李四',30)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace='北京'
print(stu1.native_pace)
print(stu2.native_pace)
print('--------类方法的使用方式-----------')
Student.cm()
print('--------静态方法的使用方式-----------')
Student.method()
|
动态绑定属性和方法
面向对象的三大特征：封装，继承，多态
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| class Car:
def __init__(self,brand):
self.brand=brand
def start(self):
print('汽车已启动')
car=Car('宝马X5')
car.start()
print(car.brand)
'''
在构造函数内部，我们使用 self.brand = brand 将传入的 brand 参数赋值给对象的 brand 属性。
这样，在创建 Car 对象时，可以通过传入品牌名称来初始化 brand 属性。
然后，我们使用 car = Car('宝马X5') 创建了一个 Car 对象，并将品牌名称传入构造函数中进行初始化。
接下来，我们调用了 car.start() 方法来启动汽车，并使用 print(car.brand) 打印了汽车的品牌名称。
'''
|
封装
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| class Student:
def __init__(self,name,age):
self.name=name
self.__age=age
def show(self):
print(self.name,self.__age)
stu=Student('张三',20)
stu.show()
print(stu.name)
print(stu._Student__age)
|
继承
super()
在 Python 中，super() 是一个内置函数，用于调用父类（超类）的方法。它可以在子类中调用父类的方法，以便在子类中扩展或修改父类的行为。
使用 super() 函数时，通常是在子类的方法中调用父类的同名方法。这样可以实现子类继承父类的行为，并且可以在子类中添加额外的逻辑。
下面是一个简单的示例，说明了 super() 的用法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| class Parent:
def __init__(self, name):
self.name = name
def greet(self):
print(f"Hello, {self.name}!")
class Child(Parent):
def __init__(self, name, age):
super().__init__(name)
self.age = age
def greet(self):
super().greet()
print(f"I am {self.age} years old.")
child = Child("Tom", 10)
child.greet()
|
在上述代码中，我们定义了一个父类 Parent 和一个子类 Child。子类 Child 继承了父类 Parent 的属性和方法。
在子类的构造函数 __init__ 中，我们首先使用 super().__init__(name) 调用父类的构造函数，以便初始化继承的属性。然后，在子类的 greet 方法中，我们使用 super().greet() 调用父类的 greet 方法，以便在子类中扩展父类的行为。
输出结果为：
1
2
| Hello, Tom!
I am 10 years old.
|
可以看到，在子类的 greet 方法中，先输出了父类的问候语，然后再输出子类自己的信息。这就是使用 super() 函数来调用父类方法的基本用法。
方法重写
在 Python 中，方法重写（Method Overriding）是指在子类中定义父类中已经存在的方法。这样，子类将使用自己的实现来替代父类中的方法。
当子类重新定义一个与父类中同名的方法时，子类的方法将覆盖（重写）父类的方法。当我们调用该方法时，将执行子类中的实现。
方法重写允许我们在子类中修改、扩展或定制父类的行为，从而实现多态性。通过重写父类的方法，我们可以根据子类的特定需求来提供不同的实现。
下面是一个简单的示例，说明了方法重写的概念：
1
2
3
4
5
6
7
8
9
10
11
12
13
| class Parent:
def greet(self):
print("Hello, I am the parent.")
class Child(Parent):
def greet(self):
print("Hello, I am the child.")
parent = Parent()
parent.greet()
child = Child()
child.greet()
|
在上述代码中，我们定义了一个父类 Parent 和一个子类 Child。父类中有一个 greet 方法，输出一条父类特定的问候语。子类中也有一个同名的 greet 方法，但它输出一个子类特定的问候语。
当我们分别创建父类对象和子类对象，并调用它们的 greet 方法时，会根据对象的类型执行相应的方法。父类对象调用的是父类的方法，子类对象调用的是子类的方法。这就是方法重写的效果。
需要注意的是，子类重写父类的方法时，方法名、参数和返回值类型必须与父类中的方法保持一致。否则，将会导致方法重载（Method Overloading），而不是方法重写。
object类
1
2
3
4
5
6
7
8
9
10
11
| class Student:
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
return '我的名字是{0}，今年{1}岁'.format(self.name,self.age)
stu=Student('张三',20)
print(dir(stu))
print(stu)
print(type(stu))
|
多态
静态语言和动态语言关于多态的区别
特殊方法和特殊属性
1
2
3
4
5
6
7
8
9
10
11
| class Student:
def __init__(self,name):
self.name=name
def __add__(self, other):
return self.name+other.name
stu1=Student('张三')
stu2=Student('李四')
s=stu1+stu2
print(s)
|
类的浅拷贝与深拷贝
模块
模块中包含函数，类，语句，类当中包含类属性，类方法，静态方法，实例属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| def fun():
pass
def fun2():
pass
class Student:
native_place='浙江'
def eat(self,name,age):
self.name=name
self.age=age
@classmethod
def cm(cls):
pass
@staticmethod
def sm():
pass
|
模块的导入
1
2
| from calc import add
print(add(10,20))
|
1
2
3
4
|
import calc
print(calc.add(10,20))
print(calc.div(20,10))
|
以主程序形式运行
1
2
3
4
5
| def add(a,b):
return a+b
if __name__ == '__main__':
print(add(10,20))
|
python中的包
1
2
3
|
import package.module_A as ma
print(package.module_A.a)
|
1
2
3
4
|
from package import module_A
from package.module_A import a
|
Python中常用的内置模块
1
2
3
4
5
6
7
8
9
10
11
12
| import sys
import time
import urllib.request
print(sys.getsizeof(24))
print(sys.getsizeof(45))
print(sys.getsizeof(True))
print(sys.getsizeof(False))
print(time.time())
print(time.localtime(time.time()))
print(urllib.request.urlopen('https://www.baidu.com/index.htm').read())
|
模块与包 知识点总结
编码格式
文件的读写操作
上面的文件名字叫a.txt
1
2
3
| file=open('a.txt','r')
print(file.readlines())
file.close()
|
常用的文件打开方式
1
2
3
| file=open('b.txt','w')
print('helloworld')
file.close()
|
1
2
3
4
5
6
7
8
9
10
|
file=open('c.txt','a')
lst=['java','go','python']
file.writelines(lst)
file.close()
|
with语句（上下文管理器）
目录操作
os模块操作目录相关函数
1
2
3
4
5
6
7
8
9
10
| import os
print(os.getcwd())
lst=os.listdir('../practice')
print(lst)
os.removedirs('A/B/C')
|
