python基础知识

一、简介

1.1、概念

python是一门强类型的动态脚本语言
强类型：不允许不同类型相加，否则会报错

123 + 'abc'

Traceback (most recent call last):
  File "D:/3.dev/pyworkspace/test02/py_00_control.py", line 2, in <module>
    123 + 'abc'
TypeError: unsupported operand type(s) for +: 'int' and 'str'

动态语言：不显示声明数据类型，赋值时确定一个变量的类型

# 代码无需大括号，通过缩进方式编写（4个空格）
abc = 10
if abc == 10:
    print("hello 1")

# 这里再次给abc赋值不同类型值不换报错，只是改变了变量类型
abc = '10'
if abc == 10:
    print("hello 2")
else:
    print("world")

hello 1
world

脚本语言：指运行代码只需要解释器，不需要编译器

1.2、数据类型

1.2.1、介绍

基本类型

number类型：整型Int、长整形long、浮点数float、复数complex

boolean类型：true、false

String类型：

高级类型

元组tuple：内部元素不可修改

列表List：内部元素可修改

集合Set：内部元素无序

字典dict：key-value形式

1.2.2、常用转换函数

int(x,[base])：将x转换为整数
long(x,[base])：将x转换为长整数
float(x)：将x转换为浮点数
str(x)：将x转换为字符串
tuple(s)：将序列s转为元组
list(s)：将序列s转为列表
set(s)：将序列s转为set集合
dict(d)：创建字典，d必须为一个序列（key,value）元组

二、循环控制

2.1、三元条件运算符

格式：A=Y if X else Z

num=int(input('输入一个整数：'))
print(num if num > 100 else '输入值小于100')

输入一个整数：10
输入值小于100

2.2、while循环

count = 0
while count <= 9:
    print(count, end=' ')
    if count == 10:
        break
    count += 1
else:
    print('end')

0 1 2 3 4 5 6 7 8 9 end

2.3、 for循环

values = ['A', 'B', 'C', 'D']
for value in values:
    print(value, end=' ')

values = ['A', 'B', 'C', 'D']
for i in range(len(values)):
    print(values[i], end=' ')

A B C D A B C D 

2.4、循环嵌套

# 九九乘法表
j = 1
while j <= 9:
    i = 1
    while i <= j:
        print('%d*%d=%d' % (i, j, i*j), end='\t')
        i += 1
    print()
    j += 1

for j in range(1, 10):
    for i in range(1, j+1):
        print('%d*%d=%d' % (i, j, i*j), end='\t')
        i += 1
    print()
    j += 1

1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

三、切片

切片操作是从一个父列表（元组、字符串）中，获取一个子集；
格式：列表[start:end[:step]]
start表示开始偏移量，end表示终止偏移量，step表示步长

my_list = [1, 2, 3, 4, 5]

# 取全部值
print(my_list[:])

# 从下标2开始取值
print(my_list[2:])

# 取下标2前面的值
print(my_list[:2])

# 取下标1到5，且步长为2的值
print(my_list[1:5:2])

# 步长为负数，反向提取
print(my_list[::-1])

# 从倒数第二个开始取值
print(my_list[-2:])

[1, 2, 3, 4, 5]
[3, 4, 5]
[1, 2]
[2, 4]
[5, 4, 3, 2, 1]
[4, 5]

四、集合

4.1、列表

4.1.1、创建方式

# 直接创建
my_list = [1, 2, 3, 'a', 'b', 'c']
print(my_list)

# 使用list()函数创建
my_list = list('abc')
print(my_list)

# 使用range()函数创建 格式：range[[start,] end [,step]] end必须，其它可选
my_list = list(range(1, 10, 2))
print(my_list)

# 使用推导式生成
my_list = [x for x in range(1, 10, 3)]
print(my_list)
my_list = [x*2 for x in range(1, 10, 3)]
print(my_list)

[1, 2, 3, 'a', 'b', 'c']
['a', 'b', 'c']
[1, 3, 5, 7, 9]
[1, 4, 7]
[2, 8, 14]

4.1.2、常见操作

# append()添加元素
my_list = [1, 2, 3]
my_list.append('a')
print(my_list)

# 列表相+，会创建一个新的列表对象
my_list02 = [4, 5, 6]
print(my_list + my_list02)

# extend()追加列表，与+相比，不会创建新的列表对象
my_list.extend(my_list02)
print(my_list)

# insert() 插入元素
my_list.insert(5, 'kk')
print(my_list)

# index()获取指定元素在列表中首次出现的索引
print(my_list.index(3))

# del()删除指定位置元素
del my_list[1]
print(my_list)

# pop()弹出指定位置元素，默认弹出最后一个元素
print(my_list.pop())

# remove() 直接删除元素
a = [1, 2, 3, 4, 5, 1]
a.remove(2)
print(a)

# 乘法 即复制几份元素
print(a * 2)

# len()、max()、min()函数
print(len(a))
print(max(a))
print(min(a))

# count() 统计某个元素在列表中出现次数
print(a.count(1))

# copy() 列表复制
print(a.copy())

# sort() 元素排序，会改变原列表
a.sort()
print(a)

# sorted() 元素排序，生成新列表，不会改变原列表
b = sorted(a)
print(b)

# reverse() 将元素反向存放
a.reverse()
print(a)

# clear() 清空列表内容
a.clear()
print(a)

[1, 2, 3, 'a']
[1, 2, 3, 'a', 4, 5, 6]
[1, 2, 3, 'a', 4, 5, 6]
[1, 2, 3, 'a', 4, 'kk', 5, 6]
2
[1, 3, 'a', 4, 'kk', 5, 6]
6
[1, 3, 4, 5, 1]
[1, 3, 4, 5, 1, 1, 3, 4, 5, 1]
5
5
1
2
[1, 3, 4, 5, 1]
[1, 1, 3, 4, 5]
[1, 1, 3, 4, 5]
[5, 4, 3, 1, 1]
[]

4.2、元组

4.2.1、创建方式

# 直接创建
a = 1, 2, 3, 4, 5
print(a)

a = (1, 2, 3, 4, 5)
print(a)


# 使用tuple()函数创建
a = tuple((1, 2, 3, 4, 5))
print(a)

a = tuple(range(5))
print(a)

a = tuple('12345')
print(a)

(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)
(0, 1, 2, 3, 4)
('1', '2', '3', '4', '5')

4.2.2、常见操作

# sorted() 排序
a = (1, 5, 3, 2, 4)
b = sorted(a)
print(b)

# zip(列表1, 列表2, 列表3) 将多个列表对应位置的元素组合成为元组
a = [1, 2, 3]
b = ['a', 'b', 'c']
c = zip(a,b)
print(list(c))

# 生成器使用
s = (x for x in range(10))
print(tuple(s))

[1, 2, 3, 4, 5]
[(1, 'a'), (2, 'b'), (3, 'c')]
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

4.3、字典

4.3.1、创建方式

# 直接创建
d = {'name':'zhangsan', 'age':18}
print(d)

d = dict(name='zhangsan', age=18)
print(d)

d = dict([('name','zhangsan'),('age',18)])
print(d)

# 通过fromkeys()创建值为空的字典
d = dict.fromkeys(['name', 'age'])
print(d)

{'name': 'zhangsan', 'age': 18}
{'name': 'zhangsan', 'age': 18}
{'name': 'zhangsan', 'age': 18}
{'name': None, 'age': None}

4.3.2、常见操作

# 取值
d = {'name':'zhangsan', 'age':18}
print(d['name'])
print(d.get('name'))

# 新增与修改 键不存在则新增，存在则修改
d['sex']='M'
print(d)

# update() 使用一个字典更新另一个字典，如果key重复则覆盖
d1 = {'name':'zhangsan', 'age':18}
d2 = {'age':20, 'sex':'M'}
d1.update(d2)
print(d1)

# items()元组形式返回key-value，keys()元组形式返回key，values()元组形式返回value
d = {'name':'zhangsan', 'age':18}
print(d.items())
print(d.keys())
print(d.values())
for key in d.keys():
    print(key)

zhangsan
zhangsan
{'name': 'zhangsan', 'age': 18, 'sex': 'M'}
{'name': 'zhangsan', 'age': 20, 'sex': 'M'}
dict_items([('name', 'zhangsan'), ('age', 18)])
dict_keys(['name', 'age'])
dict_values(['zhangsan', 18])
name
age

4.4、序列解包

a ,b ,c = [1, 2, 3]
print(a)
print(b)
print(c)

1
2
3

4.5、常见字符串操作

s = 'hello world'

# 替换所有指定字符
s1 = s.replace('l', 'L')
print(s1)

# 替换指定前n个字符（这里是前2个）
s2 = s.replace('l', 'L', 2)
print(s2)

heLLo worLd
heLLo world

五、OS模块

os模块可以直接调用操作系统，操作文件和目录

5.1、系统操作

import os

# ping百度地址
os.system("ping www.baidu.com")

# 访问QQ浏览器
os.system(r"D:\3.dev\soft\qqliulanqi\QQBrowser\QQBrowser.exe")

# 安装xxx程序
os.startfile(r"D:\3.dev\soft\xxx.exe")

5.2、路径操作

import os

# 打印当前工作目录路径
print(os.getcwd())

# 打印当前目下的文件/文件夹列表
print(os.listdir(os.getcwd()))

# 命令操作
os.chdir('../')
print(os.getcwd())

D:\3.dev\pyworkspace\test02
['.idea', 'py_00_control.py', 'py_01_object.py', 'py_02_basic_operations.py', 'venv']
D:\3.dev\pyworkspace

5.3、文件读写

import os

if not os.path.exists('a'):
    # 创建文件夹
    os.mkdir('a')
    
# 重命名
os.rename('a', 'b')

# 创建多级目录
os.makedirs('aa1/aa2/aa3')

# 多级目录重命名
os.renames('aa1/aa2/aa3', 'bb1/aa2/aa3')

5.4、shuitl模块

用来对文件进行拷贝、解压缩、移动、删除等操作

import shutil

# 复制文件
shutil.copyfile('1.txt', '2.txt')

# 将a目录下b目录中的所有文件，复制到c目录中（处理.js和.css文件）
shutil.copytree('a/b', 'c', ignore=shutil.ignore_patterns("*.js", ".css"))

5.5、open模块

open()方法用于打开一个文件，并返回文件对象
常见格式：open(url, w/a)，
w：以写的方式打开文件
a：以追加的方式打开文件
常用方法
file.close()：关闭文件
file.flush()：刷新缓冲区，直接一次性将缓冲区数据写入文件，
file.next()：返回下一行
file.read([size])：读取指定字节数据
file.readline()：读取一行数据（包括’\n’符号）
file.readlines()：读取所有行
file.write()：写入数据到文件

# 写数据
s = 'hello world'
f = open('./1.txt', 'w', encoding='utf-8')
f.write(s)
f.close()

# 读数据
try:
    f1 = open('./1.txt', 'r', encoding='utf-8')
    s1 = f1.read()
    print(s1)
finally:
    if f1:
        f1.close()

# 读取指定字符数
with open('./1.txt', 'r', encoding='utf-8') as f:
    print(f.read(3))

# 一行行读取
f = open('./1.txt', 'r')
line = f.readline()
while line:
    print(line)
    line = f.readline()
f.close()

# 读取所有行，比较占内存，适合小文件
f = open('./1.txt', 'r', encoding='utf-8')
lines = f.readlines()
for line in lines:
    print(line)
f.close()

# 一行行写入
my_list = ['aaaa哈哈\n', 'bbbb啊啊\n', 'cccc咔咔\n']
f = open('./2.txt', 'w+', encoding='utf-8')
f.writelines(my_list)
f.seek(0) # 将文件指针移到文件开始位置
read_list = f.readlines()
for line in read_list:
    print(line.strip()) # 去掉末尾换行符
f.close()

hello world
hel
hello world
hello world
aaaa哈哈
bbbb啊啊
cccc咔咔

六、函数

6.1、定义

def 函数名称([param1, param2...]):
	....
	[return 表达式]

def testSum(a, b):
    return a + b
print(testSum(1,2))

def testUser(name, age):
    print('姓名{0}，年龄{1}'.format(name, age))
    print('姓名%s，年龄%d' % (name, age))
testUser('张三', 18)

3
姓名张三,年龄18
姓名张三，年龄18

6.2、变量作用域

# 全局变量
c = 1
def testSum(a):
    # 局部变量
    b = 2
    # 就近原则
    c = 2
    return a+b+c
print(testSum(1))
print(c)

# 使用global关键字改变全局变量的值
def changeC():
    global c
    c = 2
changeC()
print(c)

5
1
2

6.3、默认参数

# 默认参数，不传值时使用默认参数值
def test(a=1, b=2):
    print(a+b)
test()
test(2, 3);

3
5

6.4、可变参数

# 可变参数，在参数名前加一个*号表示将多个参数收集到一个元组对象中，两个**号则是放到字典中
def test1star(a, b, *c):
    print(c)
test1star(1, 2, 3, 4, 5)

def test2star(a, b, **c):
    print(c)
test2star(1, 2, c1=3, c2=4, c3=5)

(3, 4, 5)
{'c1': 3, 'c2': 4, 'c3': 5}

6.5、高阶函数

指函数中的参数不仅可以是变量，也可是另一个函数，即函数式编程

def test1(a):
    return a*a

def test2(fun,b):
    return fun * b

print(test2(test1(2),5))

20

6.6、闭包

在python中，闭包意味着嵌套定义，内部函数使用外部函数中定义的变量，外部函数返回内部函数名；
如果调用一个函数X，而函数X返回一个函数Y，那么函数就称为闭包；
定义示例

# 基本格式
def funX(param1):
    def funY(param2):
        return param1 * param2
    return funY
f = funX(2)
print(f(3))

# 闭包传入函数
def log(fun):
    def wrapper(a, b):
        fun('姓名{0}，年龄{1}'.format(a, b))
    return wrapper
f = log(print)
f("张三", "18")

6
姓名张三，年龄18

6.7、装饰器

装饰器本质是一直闭包，使用@符号定义实现，格式：@装饰器名称，装饰器定义在函数或类上

# 日志装饰器
import time

def writeLog(func):
    try:
        f = open('./1.txt', 'a')
        f.write(func.__name__)
        f.write('\t')
        f.write(time.asctime())
        f.write('\n')
    except Exception as e:
        print(e.args)
    finally:
        f.close()

# 在不修改源代码基础上，添加日志功能
def log_decorator(fun):
    def wrapper():
        # 添加调用日志功能的方法
        writeLog(fun)
        fun()
    return wrapper

@log_decorator
def fun1():
    print('hello 1')

@log_decorator
def fun2():
    print('hello 2')

fun1()
fun2()

fun1	Thu Oct 29 23:02:27 2020
fun2	Thu Oct 29 23:02:27 2020

七、类与对象

python不仅支持面向过程编程，也支持面向对象编程

7.1、定义

# 格式
class 类名(父类名):
   类体

# pass表示什么都不做，为空语句
class User:
    pass

# 定义一个user类
class User:
    # 定义构造方法__init__，第一个参数为self
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age

    # 实例方法
    def getUserInfo(self):
        return '姓名{0}，年龄{1}'.format(self.name, self.age)

user = User('张三', 18)
print(user.getUserInfo())

7.2、属性与方法

# 类属性
class User:
    address = 'beijing'
    # ...省略
print(User.address)

# 类方法
class User:
    address = 'beijing'
    # 指定类方法注解
    @classmethod
    def getAddress(self):
        return self.address
print(User.getAddress())

7.3、常见内置方法

def __init__(self):初始化对象，在创建新对象时调用
def __del__(self):释放对象，在对象被删除之前调用
def __new__(cls, *args, **kwargs):实例的生成操作
def __str__(self):在使用print语句时调用
def __getitem__(self, item):获取序列索引key对应的值，相当于seq[key]
def __len__(self):调用内联函数len()
def __getattr__(self, item):获取属性值
def __setattr__(self, key, value):设置属性值
def __gt__(self, other):判断self是否大于other
def __lt__(self, other):判断self是否小于other
def __ge__(self, other):判断self是否大于或等于other
def __eq__(self, other):判断self是否等于other
def __call__(self, *args):将实例对象当做函数调用

7.4、运算符与类专有方法

加减法： +与 __add__、 -与__sub__
比较符： <与 __lt__、 <=与 __le__、 >与 __gt__、 >=与 __ge__、 ==与 __eq__、 !=与 __ne__
异或与： |与 __or__、 ^与 __xor__、 &与 __and__
位移： <<与 __lshift__、 >>与 __rshift__
其它计算： *与 __mul__、 /与 __truediv__、 %与 __mod__（取余）、 //与 __floordiv__（整数除）、 **与 __pow__（指数运算）

# 示例
a = 2
b = 3
print(a.__add__(b))
print(a.__sub__(b))
print(a.__mul__(b))
print(a.__truediv__(b))
print(a.__pow__(b))
print(a.__gt__(b))
print(a.__eq__(b))
print(a.__lt__(b))

5
-1
6
0.6666666666666666
8
False
False
True

7.5、私有属性与方法

语法：两个下划线__开头的为私有属性/方法
类内部可以直接访问，类外部使用 _类__私有属性/方法方式访问

class User:
    phone = '18866667777'
    __address = 'beijin'    # 私有类属性

    def __init__(self,name,age):
        self.name = name
        self.__age = age    # 私有实例属性

    def getUserName(self):
        return '姓名{0}'.format(self.name)

    def __getUserAge(self): # 私有方法
        return '年龄{0}'.format(self.__age)

user = User('张三', 18)
print(User.phone)
print(user.name)
print(user.getUserName())
# print(user.__age) # 报错
# print(user.__getUserAge) # 报错

18866667777
张三
姓名张三
Traceback (most recent call last):
  File "D:/3.dev/pyworkspace/test02/py_00_control.py", line 489, in <module>
    print(user.__age) # 报错
AttributeError: 'User' object has no attribute '__age'

7.6、isinstance()函数

与type()函数类似，用于判断对象类型，格式：isinstance(object, classinfo)

s = 'hello'
print(type(s))
print(isinstance(s, str))
print(isinstance(s, int))
print(isinstance(s, (str, int, list)))  # 判断s是否在元组中

<class 'str'>
True
False
True

7.7、继承

python支持多继承

# 格式
class 子类(父类):
	类体

class Person:
    def eat(self):
        print("人可以吃饭")
    def sleep(self):
        print("人需要睡觉")

class User(Person):
    def shop(self):
        print("用户喜欢购物")
    # 方法重写
    def sleep(self):
        print('人一天需要睡8小时')
user = User()
user.eat()
user.shop()
user.sleep()

人可以吃饭
用户喜欢购物
人一天需要睡8小时