【Python】01 Python基础

一、Python语言的特点(优点)

1、简单易用，支持在macOS、Windows、Unix等操作系统适用

2、编程语言，大量的数据结构、支持开发大型程序

3、错误检查很多

4、高级语言，内置灵活数组和字典，更通用的数据类型

5、模块化，便于复用

6、内置大量标准模块(包括 I/O、系统调用、套接字，甚至还包括 Tk 图形用户界面工作套件。)

7、解释型语言，无需编译和链接，节约开发时间

8、解释器支持交互式操作

9、超好用的计算器

10、简洁、易懂、代码短

11、可扩展

 

二、Python解释器

1、调用解释器

默认安装路径：

/usr/local/bin/python3.9

建立软链接使得输入python时找到安装的新版本

ln -f /usr/local/bin/python3.9 /usr/local/bin/python

传入参数：解释器读取命令行参数，把脚本名与其他参数转化为字符串列表存到 sys 模块的 argv 变量里。

交互模式：主提示符，提示输入下一条指令，主提示符通常用三个大于号（>>>）表示；输入连续行时，显示次要提示符，默认是三个点（...）。

2、解释器的运行环境

声明文件的编码，文件的第一行要写成特殊注释。句法如下：

# -*- coding: encoding -*- 
# -*- coding: uft-8 -*-

三、快速入门

1、数字

（1）支持 加+ 减- 乘* 除/ 取整// 取余% 乘方**

（2）除法运算返回结果为浮点数

（3）混合运算中包含浮点数，则结果为浮点数

（4）交互模式下，上次输出的表达式会赋给变量 _

D:\>python
Python 3.9.0 (tags/v3.9.0:9cf6752, Oct  5 2020, 15:34:40) [MSC v.1927 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 1+1 // 加
2
>>> 5-2 // 减
3
>>> 2*4 // 乘
8
>>> 2/4 // 除
0.5
>>> 2//4 // 除法取整
0
>>> 17%4 // 取余
1
>>> 4**3 // 乘方
64
>>> 4+1.0 //混合类型运算
5.0
>>> 1+_ // 交互模式下，上次输出的表达式会赋给变量 _
6.0
>>>

2、字符串

（1）转义字符

>>> 'I\'m a teacher' // 反斜杠 \ 用于转义
"I'm a teacher"
>>> "I'm a teacher"
"I'm a teacher"
>>> 'I'm a teacher'
  File "<stdin>", line 1
    'I'm a teacher'
       ^
SyntaxError: invalid syntax
>>> 'C:\usr\local\bin'
  File "<stdin>", line 1
    'C:\usr\local\bin'
                      ^
SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \uXXXX escape
>>> r'C:\usr\local\bin' // 不希望前置 \ 的字符转义成特殊字符，可使用原始字符串，在引号前添加 r 即可
'C:\\usr\\local\\bin'

（2）注意

>>> text = ('Put several strings within parentheses '
...  'to have them joined together.')
>>> text 
'Put several strings within parentheses to have them joined together.'
>>> 'py''thon' // 两个字面值合并
'python'
>>> a = "Py"
>>> a + "thon" // + 拼接
'Python'
>>> a 'thon'
  File "<stdin>", line 1
    a 'thon'
      ^
SyntaxError: invalid syntax
>>> a = "python"
>>> a[0] // 索引从0开始
'p'
>>> a[-2]
'o'
>>> a[:] // 切片，省略开始索引即0、省略结束索引即-1
'python'
>>> a[:2] 
'py'
>>> a[1:2] // 左包含右不包含
'y'
>>> a[8] // 索引越界报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> a[2:8] // 切片越界自动处理
'thon'
>>> len(a) //len字符串长度
6
>>>
>>> a = "python"
>>> a[0]="P" // 字符串不能修改
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

（3）实践

name = "congcong"
item = "My name is {names}, I am {years} old"

print(name.capitalize()) # 首字母大写
print(name.count("c")) # 统计字母个数
print(name.center(50, "-")) # 50个字符，不够的用-补充完整且居中,---------------------congcong---------------------
print(name.encode()) # 编码
print(name.endswith("g")) # 判断是否以xx结尾，是的话返回True
print(name.expandtabs(tabsize=20)) # 将\t即tab键转成多少个空格,# name = "cong\tcong"
print(name.find("g")) # 找到字母的索引
print(item.format(names=name, years=27))
print(item.format_map({"names":name, "years":27}))
print(item.isalnum()) # 判断是否英文字符+1234567890
print("23ab".isalnum())
print("Cc".isalpha()) # 判断是否英文字符
print("12".isdecimal()) # 判断是否十进制
print("1A".isdecimal())
print(name.isdigit()) # 判断是否数字
print("ab".isidentifier()) # 判断是否一个合法的标识符/变量名，即是否符合变量名的命名规则
print(name.islower()) # 判断是否小写
print("123".isnumeric()) # 判断是否只有数字
print(" ".isspace()) # 判断是否空格
print("My Name".istitle()) # 判断是否每个单词以大写字母开头
print(name.isprintable()) # 判断是否可以打印,tty file和drive file不支持打印
print("ABC".isupper()) # 判断是否大写
print("+".join(["1", "2", "3"])) # 用x连接
print(name.ljust(50, "*")) # 50个字符，不够的用*补充完整，原字符串在左侧
print(name.rjust(50, "*")) # 50个字符，不够的用*补充完整，原字符串在右侧
print("Abc".lower()) # 所有变小写
print(name.upper()) # 所有变大写
print("\n ----abc----".lstrip()) # 左侧去掉空格和回车
print("----abc---- \n".rstrip()) # 右侧去掉空格和回车
print("   abc  \n".strip()) # 去掉首尾的空格和回车
p = str.maketrans("cong", "1234") # 对应
print(name.translate(p)) # 转换
print("congcong".replace("c", "C")) # 将c替换成C
print("congcong".replace("c", "C", 1)) # 将第1个c替换成C
print("congcong".rfind("c")) # 找到最右边的c的索引，即找到最后一个c的索引
print("cong cong".split()) # 将字符串以空格分割成列表
print("1+2+3+4".split("+")) # 以+分割
print("1+2\n+3+4".splitlines()) # 自动识别不同系统的换行符，且以换行符分割
print("Ab从D".swapcase()) # 将大写字母<->小写字母;aB从d
print("cong cong".title()) # 将每个字符转换为title格式；Cong Cong
print("cc".zfill(5)) # 5个字符，不够的用0补齐

# 打印结果
Congcong
2
---------------------congcong---------------------
b'congcong'
True
congcong
3
My name is congcong, I am 27 old
My name is congcong, I am 27 old
False
True
True
True
False
False
True
True
True
True
True
True
True
1+2+3
congcong******************************************
******************************************congcong
abc
CONGCONG
----abc----
----abc----
abc
12341234
CongCong
Congcong
4
['cong', 'cong']
['1', '2', '3', '4']
['1+2', '+3+4']
aB从d
Cong Cong
000cc

3、列表实践：可嵌套列表、字典，可嵌套多层

# 列表
names = []
print(names)

names = ["4Changxiangen", "#!Zhengna", "cSonghaomiao", "Guocongcong"]
print(names)
print(names[0])
print(names[1], names[2])

# 顾头不顾尾，左闭右开;
# 切片，把一部分数据从列表中切下来
print(names[1:3])

# 跳着切片
print("*************")
print(names)
print(names[0:-1:2])
print(names[::2])
print(names[:])

# 取最后一个值
print(names[3])
print(names[-1])

# 取最后两个值
print("**********1*********")
print(names[-1:-3]) # 为空，切片只能从左到右
print(names[-3:-1]) # 错误
print(names[-2:]) # 正确

# 取前2个值
print("**********2*********")
print(names[:2])

# 追加，放在最后面
names.append("Xingjing")
print(names)

# 插入第2个位置，"1"是下标
names.insert(1, "Xiaoguo")
print(names)

# 插入第4个位置
# names.insert(3, "XiaoCong")
# print(names)

# 修改，即重新赋值
# names[3] = "Congcong"
# print(names)

# 删除"Xiaoguo"
# names.remove("Xiaoguo")
# del names[1]
# names.pop()
# names.pop(1)
print(names)

# 找某人的位置
# print(names.index("Congcong"))
# print(names[names.index("Congcong")])

# 统计"Congcong"的个数
names.insert(3, "Congcong")
print(names.count("Congcong"))
print(names)

# 反转
names.reverse()
print(names)

# 排序
# 特殊字符、数字、大写字母、小写字母
# ASCII码
names.sort()
print(names)

# 清空
# names.clear()
# print(names)

# 扩展
names1 = [1, 2, 3]
names.extend(names1)
print(names, names1)
del names1
print(names)

# 循环
for i in names:
    print(i)

四、流程控制语句

 

# 质数
# range()左包含右不包含
# 循环的 else 子句则在未运行 break 时执行
# break 跳出整个循环
for n in range(2, 20):
    for x in range(2, n):
        if n % x == 0:
            print(n, 'equals', x, '*', n//x)
            break
    else:
        # loop fell through without finding a factor
        print(n, 'is a prime number')

# 奇数、偶数
# continue 跳出本次循环，继续下一次循环
for i in range(2, 10):
    if i % 2 == 0:
        print(f"{i} is even number")
        continue
    print(f"{i} is odd number")

五、面向对象重要概念

类：关键字class

方法名：关键字def

方法与函数的区别：方法在类中，函数在类外

静态属性：类变量，在类之中，方法之外定义

动态方法：类中的def方法

实例变量：类之中，方法之内，以 self.变量名 方式定义

普通变量：在类之中，方法之中，并且前面没有 self. 开头

实例化：变量 = 类名()

通过实例对象调用类属性

通过类直接调用属性

构造方法：在类实例化的时候自动执行

# -*- coding: utf-8 -*-
# @Author : self
# @File : house.py
'''
class 类名:
    多个类属性...
    多个类方法...
'''

class House:
    # 静态属性 -> 类变量，在类之中，方法之外定义
    door = "red"
    floor = "white"

    # 构造方法，在类实例化的时候自动执行
    def __init__(self):
        # 加上 self. 变成实例变量
        print(self.door)
        # 定义实例变量 -> 类之中，方法之内，以 self.变量名 方式定义
        # 实例变量的作用域是整个类中的所有方法
        self.kitchen = "cook"

    # 动态方法
    def sleep(self):
        # 普通变量 -> 在类之中，方法之中，并且前面没有 self. 开头
        bed = "席梦思"
        print(f"在房子里可以躺在{bed}睡觉")

    def cook(self):
        print("在房子里可以做饭吃")


if __name__ == '__main__':
    # 实例化 -> 变量 = 类()
    north_house = House()
    china_house = House()

    north_house.sleep()

    # 通过类直接修改属性
    House.door = "green"
    
    # 通过实例修改属性
    north_house.door = "white"
    
    # 通过实例对象调用类属性
    print(north_house.door)
    print(china_house.door)
    
    # 通过类也可以调用属性
    print(House.door)

# -*- coding: utf-8 -*-
# @Author : feier
# @File : houyi.py
from python_pratice.python_oop.game_oop import Game
# 快速导包：Alt + enter
'''
后裔，后裔继承了 Game 的 hp 和 power。并多了护甲属性。
重新定义另外一个 defense 属性：
final_hp = hp + defense - enemy_power
enemy_final_hp = enemy_hp - power
两个 hp 进行对比，血量先为零的人输掉比赛
'''

# 类名 驼峰式
class HouYi(Game):

    def __init__(self, my_hp, enemy_hp):
        self.defense = 100
        # 继承父类的构造方法
        super().__init__(my_hp, enemy_hp)

    def fight(self):
        # 改造一下 my_hp 的计算方式
        while True:
            # 我的剩余血量
            self.my_hp = self.my_hp + self.defense - self.enemy_power
            # 敌人的剩余血量
            self.enemy_hp -= self.my_power
            print(f"我的血量：{self.my_hp} VS 敌人血量：{self.enemy_hp}")
            # self.rest(3)
            # 胜负判断
            if self.my_hp <= 0:
                print("我输了")
                break
            elif self.enemy_hp <= 0:
                print("我赢了")
                break
        super().__private_method()


if __name__ == '__main__':
    # 定义形参，传实参
    houyi = HouYi(1000, 1100)
    # 子类对象可以直接调用父类的属性和方法
    print(houyi.my_power)
    houyi.fight()
    # houyi.rest(3)
    # 演示命令行上传

# -*- coding: utf-8 -*-
# @Author : feier
# @File : log_decorator.py
import logging

# 设置基本配置
logging.basicConfig(level=logging.DEBUG)
# 自定义 logger
logger = logging.getLogger('log')

# func(a,b,c)

# 定义装饰器
def log_decorator(func):
    '''
    给传入的函数添加日志信息
    :param func: 传入的函数
    :return: 添加了log信息的函数
    '''
    def wrapper(*args, **kwargs):
        # 加上 log 信息
        logger.debug(f"装饰器:{log_decorator.__name__} -> 传入函数:{func.__name__}")
        # 调用传入的函数对象
        return func(*args, **kwargs)
    return wrapper

参考：

https://github.com/ceshiren/HogwartsLG6(拉勾教育)