Python从入门到进阶



认识Python

推荐学习视频传送门:求知讲堂2020python+人工智能 99天完整版

第一个main函数

1
2
3
4
5
def print_hi(name):
print(f'Hi, {name}') # Press ⌘F8 to toggle the breakpoint.

if __name__ == '__main__':
print_hi('PyCharm')

输出打印

ptint打印

1
2
3
4
5
6
7
8
9
10
# format 格式化输出
rs = 123
print('rs={}'.format(rs))

print('rs={0}'.format(rs))

sum_func = lambda x,y,z,c: x*y*z*c
rs1 = sum_func(4,5,6,7)
print('rs1 = %d'%rs1)
print('rs1 = %d,study %s'%(rs1, 'Python'))

logging日志

1
2
3
4
5
6
7
8
9
10
11
12
import logging
import sys

# 开启logging打印日志
LOG_FORMAT = "[%(asctime)s %(levelname)1.4s] %(message)s"
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG, format=LOG_FORMAT)

name = 'hello world'
print("%s study Python!" % name)
print("{} study Python! And realy age is {}".format(name, 20))
# %s study Python!
logging.info("%s study Python!", name)

异常-Exception

初识

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import logging

# 开启logging打印日志
import sys

LOG_FORMAT = "[%(asctime)s %(levelname)1.4s] %(message)s"
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG, format=LOG_FORMAT)


try:
i = 1 / 0
except Exception as e:
logging.error('运算时异常', e)
finally:
logging.info('异常学习')

# 输出所有异常
print(dir(Exception))

自定义异常

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
import logging

# 开启logging打印日志
import sys

LOG_FORMAT = "[%(asctime)s %(levelname)1.4s] %(message)s"
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG, format=LOG_FORMAT)

class TooLongMyException(Exception):
def __init__(self, len):
self.len = len

def __str__(self):
return '您输入的姓名数据长度是' + str(self.len) + '超过了长度'

input = input()

try:
if len(input) > 5:
raise TooLongMyException(len(input))
else:
print('您输入的数据为:' + input)
except TooLongMyException as e:
# logging.error(e)
logging.error('捕获自定义异常啦', e)
pass

结果输出:

1
2
3
4
5
6
7
8
dfsdss
--- Logging error ---
Traceback (most recent call last):
File "/Users/Lauy/mine/study_python/exception/自定义异常.py", line 20, in <module>
raise TooLongMyException(len(input))
TooLongMyException: 您输入的姓名数据长度是6超过了长度

During handling of the above exception, another exception occurred:

函数

匿名函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
result = lambda a, b, c: a * b * c
print(result(12, 34, 2))

# 类似于三元表达式
age = 15
print('每天学习' if age > 18 else '偶尔学习')

funcTest = lambda x, y: x if x > y else y
print(funcTest(2, 12))

# 直接调用函数
rs = (lambda x, y: x if x > y else y)(16, 12)
print(rs)

# ** 幂运算
rs1 = lambda x: (x ** 2) + 890
print(rs1(10))

递归函数

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
# 递归计算
def recursion_calculation(count):
if count == 1:
return 1
else:
return count * recursion_calculation(count - 1)

# recursion_calculation(5)
print('最终结果为:%d\n'%recursion_calculation(5))


# 获取路径下的文件,若是文件夹就继续向下递归
import os

def find_path_file(path):
# 获取此路径下的文件/文件夹
list_file = os.listdir(path)
for file_item in list_file:
complete_path = os.path.join(path, file_item)
# 如果是文件夹
if os.path.isdir(complete_path):
print("文件夹名:" + complete_path)
# 如果 return 的话初次函数调用的后续循环不会进行
find_path_file(complete_path)
else:
# 打印文件全路径
print('文件名:\t' + file_item)

# def main():
find_path_file('/Users/Lauy/Desktop/temp')

创建一个类对象

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
54
55
56
57
58
59
'''
类:
'''
import logging
import sys

class Person:
# 类属性
username = 'hello world'

# 初始化类的属性,在实例化时被执行,可以理解为构造器
def __init__(self):
# 实例属性
self.age = 20

# 实例方法
def study(self, name=username):
print("%s study Python!" % name)
print("{} study Python! And realy age is {}".format(name, 20))

def __str__(self):
return 'username=' + self.username + ',age=' + str(self.age)


'''
创建一个对象
------
两者打印出来的内存地址都一样的
---
4381304016
...
18
===================>
<class 'int'>
4381304016
...
20
'''
obj = Person()
print(type(obj.age))
print(id(obj.age))
# 修改的是当前对象的age值
obj.age = 18
print(id(obj.username))
obj.tag = '标签'
print(id(obj.tag))
print(obj.age)

print("===================>")
print(obj.__str__())
print("===================>")

obj1 = Person()
print(type(obj1.age))
print(id(obj1.age))
print(id(obj1.username))
obj1.tag = '标签'
print(id(obj1.tag))
print(obj1.age)

类属性和实例属性

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
import random

'''

1、可以被类对象和实例对象共同访问使用
2、类属性属于类所有,所有对象共享一份内存地址
3、实例属性只能由实例对象访问使用
4、修改类属性值需要用类 Class.类属性=值,如果是 obj.类属性值,结果只是新增实例属性
'''
class Person:

id = random.randrange(1, 100, 10)

# 初始化类的属性,在实例化时被执行,可以理解为构造器
def __init__(self, weight):
# 实例属性
self.username = 'hello world'
self.age = 20
# 动态赋值
self.weight = weight

# 实例方法
def study(self):
print("study Python!")


'''
创建一个对象
每创建一个对象都要添加属性,显然很费事,所以我们可以采用上述的 __init__方法定义实例属性,在类实例化时就被执行
'''
obj = Person(110)
# 添加实例属性
obj.gender = 'Male'
print('obj.username:%s'%obj.username)
print('obj中:类属性id为%d,username is %s, __weight is %d'%(obj.id, obj.username, obj.weight))
# 此处本是想修改类属性值,其实只是增加了一个 实例属性为id的
obj.id = 'i change id value'
# obj中:类属性id为i change id value,username is hello world, __weight is 110
print('obj中:类属性id为%s,username is %s, __weight is %d'%(obj.id, obj.username, obj.weight))

obj = Person(120)
print('obj中:类属性id为%d,username is %s, __weight is %d'%(obj.id, obj.username, obj.weight))

print('类属性id为%d'%Person.id)

类方法和静态方法

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
import uuid

'''
静态方法主要来存放逻辑性的代码,本身和类已经实例对象多有交互,相当于 static final field
类方法属于类所有,相当于 static method
'''
class Student:

stu_name = uuid.uuid4()

# 标识这是一个类方法
@classmethod
def study(cls):
return str(cls.stu_name) + '正在学习~'

print(Student.study())

import time
class TimeUtil:

# 标识这是一个静态方法
@staticmethod
def get_current_time():
# 时间格式化:2021:44:07/25/21
return time.strftime('%Y:%M:%D')

print(TimeUtil.get_current_time())

init方法

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
class Person:
# 类属性

# 初始化类的属性,在实例化时被执行,可以理解为构造器
def __init__(self, weight):
# 实例属性
self.username = 'hello world'
print('username address is %s'%id(self.username))
self.age = 20
# 动态赋值
self.weight = weight

# def __init__(self, __weight, hobby):
# # 实例属性
# self.username = 'hello world'
# self.age = 20
# # 动态赋值
# self.__weight = __weight
# self.hobby = hobby

# 实例方法
def study(self):
print("study Python!")


'''
创建一个对象
每创建一个对象都要添加属性,显然很费事,所以我们可以采用上述的 __init__方法定义实例属性,在类实例化时就被执行
'''
obj = Person(110)
# 添加实例属性
obj.gender = 'Male'
obj.height = 1.8
print(obj.username, obj.age, obj.gender, obj.height, obj.weight)

obj1 = Person(120)
# 添加实例属性
obj1.gender = 'Fmale'
obj1.height = 1.8
print(obj1.username, obj1.age, obj1.gender, obj1.height, obj1.weight)

new实例化

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
'''
__new__中:请使用父类的new方法,不要使用对象本身的new方法,容易造成深度递归
子类重写了父类的方法,所以只输出子类的方法了
'''
class Person:

# 初始化类的属性,在实例化时被执行,可以理解为构造器
def __init__(self, weight):
self.__weight = weight
print('Person对象初始化方法,我会后执行')

def __new__(cls, *args, **kwargs):
print('Person对象new方法,我会先执行')
# 请使用父类的new方法,不要使用对象本身的new方法,容易造成深度递归
return object.__new__(cls)

class Male(Person):

# 初始化类的属性,在实例化时被执行,可以理解为构造器
def __init__(self):
# 实例属性
print('Male对象初始化方法,我会后执行')

def __new__(cls, *args, **kwargs):
print('Male对象new方法,我会先执行')
return object.__new__(cls)

'''
Person对象new方法,我会先执行
Person对象初始化方法,我会后执行
================ 【子类重写了父类的方法,所以只输出子类的方法了】
Male对象new方法,我会先执行
Male对象初始化方法,我会后执行
'''
p = Person(105)
print("================")
m = Male()

熟知self

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
'''
特点:
self只有在类中定义实例方法的时候才有意义,在调用时候不必传入相应的参数,而是由解释器自动去解析、指向
self的名字是可以更改的,只是默认约定如此
self指的是类实例对象本身,相当于Java的this指向当前对象
'''
class People:

name = 'hello world'

def get_self(self):
print('name is %s, address is %s'%('getSelf', self))
return self

peo = People()
print(peo.get_self())
print(peo)
# True
print(id(peo) == id(peo.get_self()))

slot属性限制

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
'''
作用:
1、限制要添加的实例属性
2、节省内存空间
'''

class Student:
__slots__ = ('name', 'age', '__dict__')

def __str__(self):
return '{}...{}'.format(self.name, self.age)

stu = Student()

stu.name = 'hello world'
stu.age = 18
print(stu)
# 若未开启slots,则所有可以用的属性都将存储到这,缺点占用过多的内存空间 {'name': 'hello world', 'age': 18}
# 若已开启slots,则打印为空 {}
print(stu.__dict__)
# 报错:AttributeError: 'Student' object has no attribute 'weight'
# print(stu.weight)


'''
在继承关系中的使用:__slots
子类未声明 __slots__时,那么是不会继承父类的__slots,此时子类是可以随意的属性添加与赋值
子类声明 __slots__时,继承父类的 __slots__,也就是子类__slots__的范围是 其自身
'''
class MaleStudent:
__slots__ = ('name', 'height', 'age')
pass

m = MaleStudent()
m.name = 'study Python'
m.age = 20
m.height = 1.8
print(m.name, m.age)

函数属性property

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
54
55
56
57
58
59
60
import random

'''
函数属性:
1、通过property方法直接访问私有属性
- 本来__weight是类私有属性,然后通过property后可以直接访问,但是还是会经过定义的get_weight和set_weight方法
2、通过装饰器修饰[注解]
- @property 装饰器修饰,提供一个get方法
- @age.setter 提供age字段的set方法
- @age注解的字段名和函数名需要匹配
'''


class Person:

# 初始化类的属性,在实例化时被执行,可以理解为构造器
def __init__(self, weight):
# 实例属性
self.username = 'hello world'
self.__age = 20
# 加 __ 表示此为私有化属性
self.__weight = weight

def set_weight(self, weight):
self.__weight = weight

def get_weight(self):
return self.__weight

# 装饰器修饰,提供一个get方法
@property
def age(self):
return self.__age

# 标识age的set方法, 注意函数名为age,别错了
@age.setter
def age(self, age):
self.__age = age

# 这种方式就不能被set,只提供访问__weight方法
# weight = property(get_weight)
# 定义一个类属性,可以直接通过访问属性的形式去访问私有的属性
weight = property(get_weight, set_weight)


obj = Person(110)
# 110
print(obj.get_weight())
# 本来__weight是类私有属性,然后通过property后可以直接访问,但是还是会经过定义的get_weight和set_weight方法
obj.weight = 10
# 10
print(obj.get_weight())
obj.set_weight(23)
# 23
print(obj.weight)

# 装饰器=================
print(obj.age)
obj.age = 18
print(obj.age)

动态绑定属性 / 类方法

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
'''
动态绑定属性 / 类方法
'''

import types

# 需要被绑定的实例方法
import uuid


def study(slef):
print('我喜欢学习Python!')

@classmethod
def play(cls):
print('我喜欢玩')

class Person:
pass

p = Person()
# 动态绑定实例方法
p.study = types.MethodType(study, p)
p.study()

# 动态绑定类方法, 因为play方法单个参数self是默认的,不需要传参数
Person.play = play
Person.play()

# 动态绑定类属性
Person.id = uuid.uuid1()
print(Person.id)

单继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
'''
单继承:
默认继承超类,object
'''
class Animal(object):
def eat(self):
print('干饭了')

def sing(self):
print('唱歌了')

class dog(Animal):
def eat(self):
print('啃骨头')

class cat(Animal):
def eat(self):
print('偷鱼吃')

dog = dog()
dog.eat()

多继承

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
'''
多继承
'''

class D:
def eat(self):
print('爸爸叫吃饭了')

class C(D):
def eat(self):
print('C儿子在吃饭')

def play(self):
print('C儿子吃完饭,还能快乐玩耍')

class B(D):
def eat(self):
print('B儿子在吃饭')

# 多继承,继承的顺序为 A-B-C-D
class A(B, C):
pass

'''
广度优先遍历:
1、在执行eat方法时,会先找本对象a中是否包含,如果没有就向上查找B,如果B中有eat方法就返回。如果没有,就再去找父亲C,找到返回。
2、同理向上查找,直至超类object。没有就报错了【'A' object has no attribute 'eat1'】
'''
a = A()
# B儿子在吃饭
a.eat()
# C儿子吃完饭,还能快乐玩耍
a.play()

多态

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
'''
多态条件
1、继承
2、子类重写父类方法
'''
'''
单继承:
默认继承超类,object
'''
class Animal(object):
def eat(self):
print('干饭了')

@staticmethod
def commonStaticSonClassMethod(obj):
# 多态:调用的是父类静态方法,实际调用的确实子类对象的方法,
obj.eat()

class dog(Animal):
def eat(self):
print('啃骨头')

class cat(Animal):
def eat(self):
print('偷鱼吃')

class_list = [dog(), cat()]

for item_class in class_list:
Animal.commonStaticSonClassMethod(item_class)

私有化

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
import random

'''
私有化属性:
1、私有化的 实例属性,不能再被外部直接访问,可以在本类中使用修改
2、在属性名前加 __ 就可以变成私有化了
'''
class Person:

id = random.randrange(1, 100, 10)

tag_ = '后面单下划线,避免属性名与Python关键字冲突'

# 初始化类的属性,在实例化时被执行,可以理解为构造器
def __init__(self, weight):
# 实例属性
self.username = 'hello world'
self.age = 20
# 加 __ 表示此为私有化属性
self.__weight = weight

def __set_id(self):
self.id = '我是私有化方法'
return self.id

# 只能允许本身或者子类访问,不能同步from ** import * 导入
def _protected_method(self):
print('我是受保护的方法')

def __magic__(self):
print('魔法方法,一般是Python自有的')

# 实例方法
def get_person(self):
print('我在对象内部先调用了:' + self.__set_id())
return '{}的年龄是{},体重{}'.format(self.username, self.age, self.__weight)


obj = Person(110)

print(obj.get_person())
# AttributeError: 'Person' object has no attribute '__weight'
# print(obj.__weight)

注意:

单例模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
'''
单例模式
'''
class Person:

# 初始化类的属性,在实例化时被执行,可以理解为构造器
def __init__(self):
pass

def __new__(cls, *args, **kwargs):
# 单例模式,线程不安全的
if not hasattr(cls, '_instance'):
cls._instance = object.__new__(cls)
return cls._instance

p1 = Person()
p2 = Person()
print(id(p1))
print(id(p2))

内置类方法

析构方法

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
class Animal:
def __init__(self, name):
self.name = name
print('这是构造初始化方法')

'''
析构方法:
主要的应用就是来操作对象的释放,一旦释放完毕,对象便不能再使用
当在某个作用域下面,没有被使用[引用]的情况下,解析器会自动的调用此函数,来释放此对象所占的内存空间
'''
def __del__(self):
print('%s 这个对象被彻底清理了,内存空间也释放了'%self.name)

dog = Animal('哈士奇')
print(dog.name)
# 手动的去清理删除对象 [name 'dog' is not defined]
# del dog
# print(dog) # 对象已被清理,会报错
input('程序等待中,请输入......')

'''
输出示例:

这是构造初始化方法
哈士奇
程序等待中,请输入......1
哈士奇 这个对象被彻底清理了,内存空间也释放了
'''

数据库操作

MySQL

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
from pymysql import *

connection = connect(host='127.0.0.1', user='root', password='root',
database='blue', charset='utf-8', autocommit=False)
# autocommit=True, 如果插入数据,是否自动提交? 和conn.commit()功能一致。
# 必须有一个游标对象, 用来给数据库发送sql语句, 并执行的.
try:
cursor = connection.cursor()
insert_sql = '''
INSERT INTO tb_student(username, grade) values ('Lauy', '二年级')
'''
cursor.execute(insert_sql) # 插入
connection.commit()

cursor.execute('SELECT * FROM tb_student') # 查询
# 移动游标指针到最后,获取所有的查询结果
result = cursor.fetchall()
# 返回执行sql语句影响的行数
print(cursor.rowcount)
# 关闭游标
cursor.close()
# 关闭连接
connection.close()
# 输出查询结果
for student in result:
print(student)
except Exception as e:
print(e)
打赏
  • 版权声明: 本网站所有文章除特别声明外,均采用 Apache License 2.0 许可协议。转载请注明出处!
  1. © 2020-2021 Lauy    湘ICP备20003709号-1

请我喝杯咖啡吧~

支付宝
微信