Python基础
环境搭建
Python的运行环境
从官网下载相应版本,下载
安装anaconda,下载
使用docker
安装pypy,官网
Python包管理
创建一个stenv目录，然后进入到stenv目录
创建虚拟环境
python3 -m venv .
激活虚拟环境
source bin/activate #windows中直接执行activate.bat
这虚拟环境就创建完成
退出虚拟环境
终端执行命令：deactivate123456789
将Python运行起来
基础语法
快速入门
'''
基本命名方式
module_name, 模块
package_name, 包
ClassName, 类 驼峰
method_name, 方法
ExceptionName, 异常
function_name, 函数 下划线
GLOBAL_VAR_NAME, 全局变量
instance_var_name, 实例
function_parameter_name, 参数
local_var_name. 本变量
'''
"""
关键字
and exec not
assert finally or
break for pass
class from print
continue global raise
def if return
del import try
elif in while
else is with
except lambda yield
"""
#基本变量
a = 3
b = 3.5
c = "hello"
d = ['1',123,3.5]
#条件判断,使用4个空格缩进，不使用tab
if a == 3:
print("a is 3")
else:
print("a is not 3")
#循环
for i in range(3):
print(i)
#函数
def add(a,b):
"""
实现两个数相加
:param a: 加数
:param b: 被加数
:return: 返回相加结果
"""
return a + b
#类
class StMath(object):
"""
实现数学计算的类
"""
def __init__(self,a_in):
"""
初始化方法
:param a_in: 初始化数值
"""
super().__init__()
self.a = a_in
def add(self,B):
"""
实现两个math对象相加
:param B: 被加math对象
:return: 相加结果
"""
return StMath(self.a + B.b)123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
基本类型
数字类型
高精度！高精度！高精度!重要的事说三遍
字符串
基本操作
#增删改查
content = "abcxabcyabc"
print(content+"123")
print(content[:2]+content[4:])
print(content.replace("abc","python"))
print(re.sub("abc","python",content)) #使用正则表达式替换
print(content.find("xyz",2)) #或"xyz" in content
print(re.findall("abc",content))123456789101112
编码问题
python3中,文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes，正是这使得两者的区分特别清晰。你不能拼接字符串和字节包，也无法在字节包里搜索字符串
一个乱码问题演示
"你好".encode("utf-8").decode("gbk")
#str,bytes再一个事例
"你好".encode("unicode-escape").decode()
ord('你')12345
List
list具有范型特征(讲完对象再回顾排序)
#增删改查
a = [1,2,3,4,5,6,7]
#增加元素
a.append(8)
#删除元素
a.remove(3)
#查找元素
a.index(6)
#修改元素
a[4] = 10
#切片操作,会忽略结束元素
a[2:5] #注意不会包括索引5的元素
a[::-1] #反序操作
#便利操作
for v in a:
print(v)
#如果属性要索引
for i,v in enumerate(a):
print(i,v)1234567891011121314151617181920212223
字典
#增删改查
stu_dict = {"name":"jack","age":21,"s**":100}
#增加
stu_dict["phone"] = "18000000000"
#删除
del stu_dict["phone"]
#修改
stu_dict["name"] = "lucy" #stu_dict.update({})
#查询
stu_dict.get("name") #和stu_dict["name"]区别1234567891011
使用函数
函数是python的一等公民,变为:
函数的参数
不可变对象
str,int,number都是不可变对象，采用值传递
a = 20
def change_value(x):
x = 100
change_value(a)
print(a) #结果仍然是201234567
可变对象
list,dict是可变对象，采用引用传递
def change_list(x):
x.append(20)
y = [1,2,3]
change_list(y)
print(y) # 结果是1,2,3,201234567
定位参数和关键字参数
定位参数必须按照次序，关键字参数可以任意打乱次序，可以赋默认值
def extract_content(tag_name,start_pos = 20)
print("tag_name is ::::::",tag_name)12
*args, **karges
使用args和kargs传入不定长参数，args捕获的定位参数被组织为元组，kargs捕获的参数被组织为字典
def extract_content(*args,**kargs):
print(args)
print(kargs)
extract_content("a",3.5,[1,2,3],name="jack",age="22")123456
数组加上*号传入会被args解包后逐个捕获
list_args = [1,2,3,4,5,6]
extract_content(*list_args)123
函数的注解
可以给参数和返回值附加元数据,对于复杂数据支持的时候可以提高易读性，提升开发效率,Python自身不做检查不做校验，不会对程序的行为产生影响，仅仅是一种约定
def add(add_a:int,add_b:int) -> int:
return add_a + add_b
print(add(10,20))1234
变量的作用阈
全局作用域与局部作用域
#下面的代码错在什么地方？使用global纠正
m = 10
def show_diff():
print("********show_diff*********")
global
n = 20
print(m)
m = 90
print(n)12345678910
函数和闭包
#函数和闭包
def create_sum():
sum = 0
def sum_all(a_in):
nonlocal sum
sum += a_in
return sum
return sum_all
s_custom = create_sum()
#本质是什么
#print(s_custom.__closure__[0].cell_contents)
print(s_custom(10))
print(s_custom(20))
print(s_custom(30))12345678910111213141516
如何做为一等公民?
可以赋值
p = add
print(p(10,20))12
可以作为参数传递(linux,spring设计)
def download_url(url_str,extract_rule):
print("下载了某个网页")
result = "<html><head><a href='//www.baidu.com'></a></head></html>"
urls = extract_rule(result)
print("页面的所有地址是:",urls)
def normal_url_rule(result):
return re.findall("<a\s+href=\'(.*?)\'",result)
def no_http_url_rule(result):
origin_url = re.findall("<a\s+href=\'(.*?)\'",result)
return ["http:"+ url for url in origin_url]
download_url("",no_http_url_rule)123456789101112131415
做为返回值
def math_rule():
def rule(a,b):
return a+b
return rule
rule = math_rule()
print(rule(20,30))123456789
装饰器
装饰器的本质，函数的嵌套调用
import time
#装饰器
def download_html():
time.sleep(1)
print("执行了下载操作")
def record_time(download_func):
def record_wrapper():
start_time = time.time()
download_func()
end_time = time.time()
print("下载经过了时间",end_time - start_time)
return record_wrapper
decorate_download = record_time(download_html)
decorate_download()123456789101112131415161718192021
使用语法糖，更直观的使用体验:
@record_time
def download_html():
time.sleep(1)
print("执行了下载操作")
download_html()1234567
装饰器中传递参数:
def record_time(level):
def decorate(download_func):
def record_wrapper(*args,**kargs):
print("下载网址是:",args)
print("日志等级是",level)
start_time = time.time()
download_func()
end_time = time.time()
print("下载经过了时间",end_time - start_time)
return record_wrapper
return decorate
@record_time(level=9)
def download_html():
time.sleep(1)
print("执行了下载操作")1234567891011121314151617
面向对象
面向对象的基本特点，封装、继承、多态,抽象用来设计类的层次结构
面向对象基础
self,方法重写，@classmethod @staticmethod,内置方法重写
class Person(object):
"""
定义抽象基类
"""
def __init__(self,score):
self.score = score
self.__name = "jack" #加上两个下划线，表示私有方法
@classmethod
def from_file(cls,file_name):
"""
从文件读取学生成绩
:param file_name: 文件名
:return:
"""
score = open("score.txt").read()
return cls(score)
@staticmethod
def extract_address():
return "no.90"
def run(self):
print("person run!!!!")
def __add__(self, other):
return Student(self.score + other.score)
class Student(Person):
"""
学生信息类
"""
def __init__(self,score):
super().__init__(score)
def ask(self):
print("ask a question!!")
def run(self):
super().run()
print("student run!!",self.score)
# p = Person(85)
# p.run()
s = Student.from_file("test.txt")
print(Student.extract_address())
s.run()123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051
抽象层构建
抽象基类中的抽象方法必须在子类中实现，否则子类无法实例化。
#抽象接口
from abc import ABC,abstractmethod
class Person(ABC):
"""
定义抽象基类
"""
def __init__(self):
pass
@abstractmethod
def run(self):
pass
class Student(Person):
def __init__(self):
super().__init__()
def ask(self):
print("ask a question!!")
def run(self):
print("run run run1!!")1234567891011121314151617181920212223
动态特性
运行过程中动态判断属性，设置属性,可以结合配置文件灵活实现类的加载，修改
package = __import__('st_python_base')
student_class = getattr(package,'Student')
s = student_class(90)
s.run()12345
当出现未知访问属性的时候，进行处理
def __getattr__(self, item):
print('getattr')12
内存管理
关于引用计数
import weakref
def over():
print("student is over!!!")
x = st_python_base.Student(10)
ender = weakref.finalize(x,over)
y = x123456789
关于深复制和浅复制
注意直接赋值，copy，deepcopy的区别?
from copy import copy
from copy import deepcopy
class Student(object):
def __init__(self):
self.course = [1,2,3,4,5]
self.name = "jack"
s1 = Student()
s2 = deepcopy(s1)
s1.course.append(12)
print(s2.course)123456789101112131415
上下文管理
with…as…的本质
class StTools(object):
def __enter__(self):
print("进入上下文块。。。。")
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print("从上下文块退出")
def make_sign(self):
print("test!!!")
with StTools() as st:
st.make_sign()12345678910111213141516
关于迭代器和生成器
理解yield和send
def s():
print('begin test')
a = yield 10
print(a)
b = yield 20
print('end test!')
评论（0）