Python基础

环境搭建

Python的运行环境

从官网下载相应版本,下载
安装anaconda,下载
使用docker
安装pypy,官网

Python包管理

直接使用pip
使用conda
使用虚拟环境
使用景象加速(https://pypi.tuna.tsinghua.edu.cn/simple)

创建一个stenv目录，然后进入到stenv目录
创建虚拟环境
python3 -m venv .
激活虚拟环境
source bin/activate #windows中直接执行activate.bat
这虚拟环境就创建完成
退出虚拟环境
终端执行命令：deactivate

将Python运行起来

使用终端
直接作为脚本
在编译器运行
打包为可执行程序 (pyinstaller -F source)

基础语法

快速入门

'''
基本命名方式
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)

基本类型

数字类型

高精度！高精度！高精度!重要的事说三遍

字符串

基本操作


#增删改查

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))

编码问题

python3中,文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes，正是这使得两者的区分特别清晰。你不能拼接字符串和字节包，也无法在字节包里搜索字符串

一个乱码问题演示

"你好".encode("utf-8").decode("gbk")
#str,bytes再一个事例
"你好".encode("unicode-escape").decode()
ord('你')

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)

字典

#增删改查
stu_dict = {"name":"jack","age":21,"socre":100}
#增加
stu_dict["phone"] = "18000000000"
#删除
del stu_dict["phone"]
#修改
stu_dict["name"] = "lucy" #stu_dict.update({})
#查询
stu_dict.get("name") #和stu_dict["name"]区别

使用函数

函数是python的一等公民,变为:

运行时创建
能赋值
能传参
能返回

函数的参数

不可变对象

str,int,number都是不可变对象，采用值传递

a = 20

def change_value(x):
    x = 100

change_value(a)
print(a) #结果仍然是20

可变对象

list,dict是可变对象，采用引用传递

def change_list(x):
    x.append(20)

y = [1,2,3]
change_list(y)
print(y) # 结果是1,2,3,20

定位参数和关键字参数

定位参数必须按照次序，关键字参数可以任意打乱次序，可以赋默认值

def extract_content(tag_name,start_pos = 20)
		print("tag_name is ::::::",tag_name)

*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")

数组加上*号传入会被args解包后逐个捕获

list_args = [1,2,3,4,5,6]
extract_content(*list_args)

函数的注解

可以给参数和返回值附加元数据,对于复杂数据支持的时候可以提高易读性，提升开发效率,Python自身不做检查不做校验，不会对程序的行为产生影响，仅仅是一种约定

def add(add_a:int,add_b:int) -> int:
    return add_a + add_b

print(add(10,20))

变量的作用阈

全局作用域与局部作用域

#下面的代码错在什么地方？使用global纠正
m = 10
def show_diff():
    print("********show_diff*********")
    global
    n = 20
    print(m)
    m = 90
    print(n)

函数和闭包


#函数和闭包
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))

如何做为一等公民?

可以赋值

p = add
print(p(10,20))

可以作为参数传递(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)

做为返回值

def math_rule():
    def rule(a,b):
        return a+b

    return rule


rule = math_rule()
print(rule(20,30))

装饰器

装饰器的本质，函数的嵌套调用

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()

使用语法糖，更直观的使用体验:

@record_time
def download_html():
    time.sleep(1)
    print("执行了下载操作")


download_html()

装饰器中传递参数:

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("执行了下载操作")

面向对象

面向对象的基本特点，封装、继承、多态,抽象用来设计类的层次结构

面向对象基础

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()

抽象层构建

抽象基类中的抽象方法必须在子类中实现，否则子类无法实例化。

#抽象接口
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!!")

动态特性

运行过程中动态判断属性，设置属性,可以结合配置文件灵活实现类的加载，修改

hasattr
setattr
hasattr

package = __import__('st_python_base')
student_class = getattr(package,'Student')

s = student_class(90)
s.run()

当出现未知访问属性的时候，进行处理

 def __getattr__(self, item):
         print('getattr')

内存管理

关于引用计数

import weakref
def over():
    print("student is over!!!")
    
x = st_python_base.Student(10)
ender = weakref.finalize(x,over)

y = x

关于深复制和浅复制

注意直接赋值，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)

上下文管理

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()

关于迭代器和生成器

理解yield和send

def s():
    print('begin test')
    a = yield 10
    print(a)
    b = yield 20
    print('end test!')

Python常用基础知识点