Python 核心编程

1. 数据类型
- 1.1 整型 int
- 1.2 浮点数 float
- 1.3 布尔类型 bool
- 1.4 字符串 str
- 1.5 列表 list
- 1.6 元组 tuple
- 1.7 集合 set
- 1.8 字典 dict
2. 逻辑结构、文件操作
- 2.1 分支结构和三元表达
- 2.2 循环和遍历
- 2.3 目录和路径
- 2.4 文件操作
3. 函数、类、异常处理
- 3.1 函数
- 3.2 类
- 3.3 异常处理
4. 包和模块、随机数
- 4.1 包和模块
- 4.2 随机数
5. 生成器、高阶函数
- 生成器
- 高阶函数

1. 数据类型

1.1 整型 int

没有长度限制

score = 95

type(score)

int

num = 888888888888888888888888888888888888888888888888888888888888888888888888888888

type(num)

int

num

888888888888888888888888888888888888888888888888888888888888888888888888888888

a = 4
b = 3

a + b

a - b

a * b

a / b

1.3333333333333333

a ** b

a ** (1 / b)

1.5874010519681994

import math

math.exp(3)

20.085536923187668

math.log(a)

1.3862943611198906

str(a)

'4'

c = int('5')

a > b

True

b > a

False

 a == b

False

a >= b

True

a <= b

False

a != b

True

1.2 浮点数 float

浮点数是不精准存储

score = 82.11

type(score)

float

price = 5.55555555555555555555555555555555555555555555555555555555555

price

5.555555555555555

type(price)

float

distance = 1.5e-4

distance

0.00015

a = 1.5
b = 2.7

a + b

4.2

a - b

-1.2000000000000002

a * b

4.050000000000001

a / b

0.5555555555555555

import math

a = 3.5

a ** 2

12.25

a ** (1/2)

1.8708286933869707

a = 5.6

math.exp(a)

270.42640742615254

math.log(a)

1.7227665977411035

math.log2(a)

2.4854268271702415

str(a)

'5.6'

c = float('2.3132')

2.3132

a = 3.23452

math.ceil(a)

math.floor(a)

int(a)

round(a,2)

3.23

a = 1-0.55

0.44999999999999996

a = 3.5
b = 6.43

a < b

True

a = 1 - 0.55

a == 0.45

False

# 浮点数的相等不能直接比较
math.fabs(a - 0.45) < 1e-6

True

1.3 布尔类型 bool

True 就是1 ， False 就是0

True

True

False

False

result = True

3>2

True

1==2

False

True+1

2 ** True

1 / False

---------------------------------------------------------------------------

ZeroDivisionError                         Traceback (most recent call last)

Cell In[85], line 1
----> 1 1 / False


ZeroDivisionError: division by zero

True and True

True

True and False

False

True or False

True

not False

True

not True

False

1.4 字符串 str

单引号/双引号/三单引号/三双引号

s1 = '人工智能'
s2 = "人工智能"

type(s1),type(s2)

(str, str)

s3='''这是一个多行字符串
我可以自由换行
'''

s3

'这是一个多行字符串\n我可以自由换行\n'

s4="""三双引号
一样可以灵活换行"""

s4

'三双引号\n一样可以灵活换行'

len(s4)

s4.__len__()

s="qwertyuiopezxcfvgbnhmpdsfkpisjfoid"

s[0]

'q'

s[10]

'e'

s[-1]

'd'

s[-2]

'i'

s[:3]

'qwe'

s[3:5]

'rt'

s[1:-1]

'wertyuiopezxcfvgbnhmpdsfkpisjfoi'

len(s)

#[start:stop:step]
s[1:-4:3]

'wtiecghdks'

for ele in s[5:-6:4]:
    print(ele)

y
p
c
b
p
k

s = "            erwreqw"

s.strip()

'erwreqw'

s = "   \t\n AI \t \n"

'   \t\n AI \t \n'

s.strip()

'AI'

s = "人工  \t智能"

s.strip()

'人工  \t智能'

s.replace("\t","").replace(" ","")

'人工智能'

s = "1,2,3,4,5,6  "

ls = s.strip().split(",")

ls

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

s = ",".join(ls)

'1,2,3,4,5,6'

s = "Hello World"

s.lower()

'hello world'

s.upper()

'HELLO WORLD'

s1 = "AI "
s2 = "人工智能 "

s1+s2

'AI 人工智能 '

s = 3*s1+ 5* s2

'AI AI AI 人工智能 人工智能 人工智能 人工智能 人工智能 '

s.count("AI")

'人工' in s

True

'智能' not in s

False

1.5 列表 list

元素有顺序，元素可以是任意类型，元素可以重复

ls = [1,2,3,4]

type(ls)

list

ls = list("abc")

ls

['a', 'b', 'c']

[1,2] == [2,1]

False

ls = [1,True,"asd",[1,2,3,4]]

ls

[1, True, 'asd', [1, 2, 3, 4]]

len(ls)

ls.__len__()

ls[0]

ls[:2]

[1, True]

ls[::2]

[1, 'asd']

ls[::-1]

[[1, 2, 3, 4], 'asd', True, 1]

for ele in ls:
    print(ele)

1
True
asd
[1, 2, 3, 4]

ls=[]

len(ls)

ls.insert(0,"test")

ls

['test']

ls.insert(0,"1")

ls

['1', 'test']

ls.insert(100,"2")

ls

['1', 'test', '2']

ls.insert(-100,123)

ls

[123, '1', 'test', '2']

ls.append([1,2,3])

ls

[123, '1', 'test', '2', [1, 2, 3]]

ls.extend("mech")

ls

[123, '1', 'test', '2', [1, 2, 3], 'm', 'e', 'c', 'h']

ls.remove("1")

ls.remove([1,2,3])

ls

[123, 'test', '2', 'm', 'e', 'c', 'h']

ls.remove(321)

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

Cell In[217], line 1
----> 1 ls.remove(321)


ValueError: list.remove(x): x not in list

ls.pop()

'h'

ls

[123, 'test', '2', 'm', 'e', 'c']

ls.pop(10)

---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

Cell In[220], line 1
----> 1 ls.pop(10)


IndexError: pop index out of range

ls.pop(-3)

'm'

ls

[123, 'test', '2', 'e', 'c']

ls[0] = 321

ls

[321, 'test', '2', 'e', 'c']

ls[-3:] = [1.1,2.2]

ls

[321, 'test', 1.1, 2.2]

ls.count(1)

321 in ls

True

1.6 元组 tuple

元素有顺序，可以是任意类型，不可修改

t1 = ()

type(t1)

tuple

t1

()

t2 = ("qwe")

t2

'qwe'

type(t2)

str

t3 = ("12",)

t3

('12',)

type(t3)

tuple

t4=(1,2,True,"ADSAS")

t4

(1, 2, True, 'ADSAS')

t5 = tuple("abd")

t5

('a', 'b', 'd')

t6=tuple([1,2,3,4,5,6])

t6

(1, 2, 3, 4, 5, 6)

# 元素不能修改
t6[3]=0

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In[248], line 2
      1 # 元素不能修改
----> 2 t6[3]=0


TypeError: 'tuple' object does not support item assignment

t1 = tuple("abc")

t1

('a', 'b', 'c')

len(t1)

t1.__len__()

t1[0]

'a'

t1[-1]

'c'

t1[1::-1]

('b', 'a')

# 省略括号和结构赋值
t1 = (1,4.3)

t2 = 1,4.3

t1==t2

True

p1,p2 = t2

p1,p2

(1, 4.3)

p1

p2

4.3

p1,p2,p3 = t2

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

Cell In[265], line 1
----> 1 p1,p2,p3 = t2


ValueError: not enough values to unpack (expected 3, got 2)

# 快速交换多个变量的值
A = 4
B = 5

A,B=B,A

ls = (1,2,3,True,1,3,4,2,12)

ls.count(1)

ls.count(True)

True in ls

True

False in ls

False

# tuple 元素不能修改吗？
t2 = (1,2,3)

t2[1]=3

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In[279], line 1
----> 1 t2[1]=3


TypeError: 'tuple' object does not support item assignment

t3=(1,2,[4,5,6])

# 列表是可变元素，值变了，但地址没变
t3[-1].append("ABD")

t3

(1, 2, [4, 5, 6, 'ABD'])

1.7 集合 set

元素的无序性/确定性/唯一性

s1 = {}

s1

{}

type(s1)

dict

t2 = set()

t2

set()

type(t2)

set

t3={1}

t3

{1}

t4={1,2,3,4,5,6,7}

t4

{1, 2, 3, 4, 5, 6, 7}

t5=set("abscs")

t5

{'a', 'b', 'c', 's'}

t6=set([1,2,3,4])

t6

{1, 2, 3, 4}

t7 = {1,1,1,1,2,3,4}

t7

{1, 2, 3, 4}

# 列表是可变的，不能作为集合的元素
t8 = {[1,2,3],True,"absd"}

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In[301], line 2
      1 # 列表是可变的，不能作为集合的元素
----> 2 t8 = {[1,2,3],True,"absd"}


TypeError: unhashable type: 'list'

s = set("asdfdwsf")

len(s)

s.__len__()

s.add(True)

{True, 'a', 'd', 'f', 's', 'w'}

s.add('s')

{True, 'a', 'd', 'f', 's', 'w'}

s.remove('a')

{True, 'd', 'f', 's', 'w'}

s.remove('ffff')

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

Cell In[313], line 1
----> 1 s.remove('ffff')


KeyError: 'ffff'

# 随机删除
s.pop()

'd'

{'s', 'w'}

a = {1,2,3,4,5,6,7}
b = {4,5,6,7,8,9}

a.intersection(b)

{4, 5, 6, 7}

b.intersection(a)

{4, 5, 6, 7}

a.union(b)

{1, 2, 3, 4, 5, 6, 7, 8, 9}

b.union(a)

{1, 2, 3, 4, 5, 6, 7, 8, 9}

1 in a

True

10 in b

False

1.8 字典 dict

元素成对出现，元素五顺序，key不可变，不重复，value无要求

d1 = {}

d1

{}

type(d1)

dict

len(d1)

d2 = {"name":"Tom"}

d2

{'name': 'Tom'}

d3 = {'name': 'Tom','age':12}

d3

{'name': 'Tom', 'age': 12}

len(d3)

# 可变类型不可以做key
# 可变类型： list/set/dict
# 不可变类型： int/float/bool/str/tuple*
d4 = {[1,2,3]:12}

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In[339], line 2
      1 # 可变类型不可以做key
----> 2 d4 = {[1,2,3]:12}


TypeError: unhashable type: 'list'

d5 = dict(a=1,b=2,c=3)

d5

{'a': 1, 'b': 2, 'c': 3}

len(d5)

d5.__len__()

d6 = dict(name='Tom',age=22,school='北京大学')

d6

{'name': 'Tom', 'age': 22, 'school': '北京大学'}

d6["score"]=87

d6

{'name': 'Tom', 'age': 22, 'school': '北京大学', 'score': 87}

# 有则改之，无则追加
d2["score"] = 98

d2

{'name': 'Tom', 'score': 98}

d2["score"]

# 读取不存在的key会报错
d["asd"]

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

Cell In[364], line 2
      1 # 读取不存在的key会报错
----> 2 d["asd"]


NameError: name 'd' is not defined

# 使用get读取更加安全
d6.get("abc",0)

d6

{'name': 'Tom', 'age': 22, 'school': '北京大学', 'score': 87}

d6.pop('name')

'Tom'

d6

{'age': 22, 'school': '北京大学', 'score': 87}

d.pop('age1')

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

Cell In[371], line 1
----> 1 d.pop('age1')


NameError: name 'd' is not defined

d6.keys()

dict_keys(['age', 'school', 'score'])

d6.values()

dict_values([22, '北京大学', 87])

d6.items()

dict_items([('age', 22), ('school', '北京大学'), ('score', 87)])

# 默认遍历key
for ele in d2:
    print(ele)

name
score

# 遍历key
for key in d6.keys():
    print(key)

age
school
score

# 遍历value
for value in d6.values():
    print(value)

22
北京大学
87

# 遍历键值对
for key,value in d6.items():
    print(key,value)

age 22
school 北京大学
score 87

'age' in d6

True

'age1' in d6

False

2. 逻辑结构、文件操作

2.1 分支结构和三元表达

if(1<2):
    print("1<2")

1<2

age = 25
if age >= 18:
    print("成年人")
else:
    print("未成年")

成年人

score= 89

if score >=90:
    print("优秀")
elif score >= 75:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

良好

# 三元表达

age = 3

True if age >= 18 else False

False

"成年人" if age >=18 else "未成年"

'未成年'

"成年人" if age >=18 else age

2.2 循环和遍历

num = 1
while True:
    if num < 10:
        num+=1
        print(num)
    else:
        break

for _ in range(10):
    print("Hello,Python!!!")

Hello,Python!!!
Hello,Python!!!
Hello,Python!!!
Hello,Python!!!
Hello,Python!!!
Hello,Python!!!
Hello,Python!!!
Hello,Python!!!
Hello,Python!!!
Hello,Python!!!

ls = [1,2,3,4,5,"Hello",False]
for ele in ls:
    print(ele)

1
2
3
4
5
Hello
False

s = "asdfg"
for ele in s:
    print(ele)

a
s
d
f
g

2.3 目录和路径

import os

# 路径是否存在(文件夹或文件)
os.path.exists(path="./abc")

True

# 路径拼接
os.path.join(".","abc","ddd")

'.\\abc\\ddd'

# 创建目录
save_path = "./abc/saved_weight"

# 如果不存在就创建
if not os.path.exists(path=save_path):
    os.makedirs(save_path)

# 删除文件
if os.path.exists(path="ddd.ddd"):
    os.remove()

# 删除目录
save_path = "./abc/saves_weights"
if os.path.exists(path=save_path):
    print("存在")
    os.removedirs(name=save_path)

# 遍历一个目录
root = "./"
for ele in os.listdir(root):
    if os.path.isfile(ele):
        print(ele,"文件")
    elif os.path.isdir(ele):
        print(ele,"目录")

.ipynb_checkpoints 目录
12.csv 文件
1234.txt 文件
abc 目录
P1_数据类型.ipynb 文件
P2_逻辑结构及文件操作.ipynb 文件
poem.txt 文件
saved_weight 目录

2.4 文件操作

# 打开、增删改查、关闭

f = open(file="./1234.txt",mode="r",encoding="utf8")

f.read()

'锄禾日当午\n汗滴禾下土'

f.read()

''

f.close()

# 更加优雅的写法
with open(file="./1234.txt",mode="r",encoding="utf8") as f:
    while True:
        line = f.readline().strip()
        if line:
            print(line)
        else:
            break

锄禾日当午
汗滴禾下土

# 写入：如果文件不存在则新建，如果存在则清空文件内容
with open(file="poem.txt",mode="w",encoding="utf8") as f:
        f.write("举头望明月\n低头思故乡\n")

# 追加内容
with open(file="poem.txt",mode="a",encoding="utf8") as f:
        f.write("举头望明月\n低头思故乡\n")

3. 函数、类、异常处理

3.1 函数

位置参数
默认参数
可变参数
匿名函数

# 定义参数

def fun():
    pass

# 调用
fun()

callable(fun)

True

# 位置参数

def add(a,b):
    return a+b

add(1,2)

# 默认参数

def area(r,pi=3.1415926):
    return r*r*pi

area(r=3,pi=3.14)

28.26

# 可变参数

def add_num(*args):
    s = 0
    for ele in args:
        s += ele
    return s

add_num()

add_num(1)

add_num(1,2,3,4,5)

# 匿名函数
fn = lambda x: x ** 2

fn(3)

(lambda x,y:x+y)(1,2)

3.2 类

封装
继承
多态

class Car(object):
    def __init__(self,color="Black",brand="BYD",price=50):
        '''
            自定属性
        '''
        self.color = color
        self.brand = brand
        self.price = price
    def info(self):
        '''
            自定义方法
        '''
        print(self.color,self.brand,self.price)
    def __repr__(self):
        '''
            重载父类的方法
        '''
        return 'Car'

car1 = Car(color="Blue")

car1

Car

print(car1.color)

Blue

car1.info()

Blue BYD 50

# 继承
car1.__repr__()

'Car'

o = object()

o.__repr__()

'<object object at 0x0000020EBEBE4ED0>'

# 多态
car1.__repr__()

'Car'

3.3 异常处理

异常基类 Exception
接收异常 try except else finally
抛出异常 raise

def divide(a, b):
    return a / b

divide(1,2)

0.5

divide(2,0)

---------------------------------------------------------------------------

ZeroDivisionError                         Traceback (most recent call last)

Cell In[13], line 1
----> 1 divide(2,0)


Cell In[11], line 2, in divide(a, b)
      1 def divide(a, b):
----> 2     return a / b


ZeroDivisionError: division by zero

"""
    异常处理
        - 守株待兔的操作
        - 如果没有发生异常：不做任何额外处理
        - 如果发生了异常，引导程序做出合理化的处理
"""
a = 3
b = 0
try:
    result = divide(a,b)
    print(result)
except Exception as e:
    print(e)
else:
    print("没有发生错误")
finally:
    print("不管是否发生错误，我都会执行")

print("这里依然可以执行")

division by zero
不管是否发生错误，我都会执行
这里依然可以执行

# 抛出异常

a = 2
b = 3

def divide(a, b):
    if isinstance(a, int) and isinstance(b, int) and b != 0:
        return a / b
    else:
        raise Exception("参数错误")

divide(2,1)

2.0

divide(1,0.3)

---------------------------------------------------------------------------

Exception                                 Traceback (most recent call last)

Cell In[23], line 1
----> 1 divide(1,0.3)


Cell In[21], line 10, in divide(a, b)
      8     return a / b
      9 else:
---> 10     raise Exception("参数错误")


Exception: 参数错误

4. 包和模块、随机数

4.1 包和模块

包和模块是代码组织的一种方式，包就是一个文件夹，模块就是一个源码文件
避免重复造轮子，利用前人写好的包和模块
托管平台：pip 和 conda 管理工具

import numpy as np

np.__version__

'1.23.5'

np.e

2.718281828459045

import os

os.path.exists("./")

True

from matplotlib import pyplot as plt

定义自己的模块
在项目文件夹中新建一个文件夹名为 utils ,在里面新建一个 math.py文件，然后编辑函数

from utils import math

math.add(3,23)

math.sub(43,1)

4.2 随机数

- 概率论中随机试验产生的结果
- 数据科学中随机数很重要

import random

# 均匀分布
# 按照均匀分布生成一个随机数
random.uniform(0,100)

4.646385375119754

random.randint(0,100)

# 高斯分布
random.gauss(mu=0,sigma=1)

-2.9510713969400872

# 洗牌操作
x = [1,2,3,4,5,6,7,8,9,0]
print(x)
random.shuffle(x)
print(x)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[0, 6, 1, 4, 5, 7, 3, 9, 8, 2]

# 随机抽取
x = [1,2,3,4,5,6,7,8,9,0]
result = random.choice(x)
print(result)

ls = random.sample(x,3)
print(ls)

[5, 9, 3]

# 固定随机数，方便复现：种子固定了，随机规则就产生了，
random.seed(0)
x = [1,2,3,4,5,6,7,8,9,0]
result = random.sample(x,2)
print(result)

[7, 0]

5. 生成器、高阶函数

生成器

- 当数据集很大时，我们很难一次性将所有数据加载到内存中，而是按需加载，这时候就要用到生成器
- 模型训练时，数据经常会打包成生成器
- yield 和 return
- 列表生成器
- 打包数据集

# return 返回并跳出函数
def get_data():
    ls = [0,1,2,3,4,5,6,7,8,9]
    for ele in ls:
        return ele

get_data()

# yield 构建生成器
def get_data():
    ls = [0,1,2,3,4,5,6,7,8,9]
    for ele in ls:
        yield ele

gen = get_data()

for ele in gen:
    print(ele)

ls = list(range(10))

ls

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 列表解析式 ： for循环 + if判断
ls1 = [ele for ele in ls if ele % 2 == 1]

ls1

[1, 3, 5, 7, 9]

# 这样也可以构建生成器
gen1 = (ele for ele in ls if ele % 2 == 1)

for ele in gen1:
    print (ele)

# 通过生成器来读取数据集

def get_dataset():
    with open(file="dataset.csv",mode="r",encoding="utf8") as f:
        line = f.readline()
        while True:
            line = f.readline()
            if line:
                yield line
            else:
                break

gen = get_dataset()

# 生成器是一次性的，从头读到尾之后，再想重新读就又要新的生成器了
next(gen)

'1.70,70,23,89\n'

for ele in gen:
    print(ele)

1.67,71,23,79

1.75,72,22,84

1.74,73,23,86

1.79,74,21,56

高阶函数

- 把函数当做参数，自动化的实现底层遍历
- 数据科学中高阶函数很有用，可以极大提升效率
- map 映射
- reduce 聚合
- filter 过滤
- sorted 排序

ls = [0,1,2,3,4,5,6,7,8,9]

def add(ele):
    return ele + 0.5

ls1 = list(map(add,ls))

ls1

[0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5]

reduce

from functools import reduce

sum(ls)

def add(a,b):
    return a+b

reduce(add,ls)

reduce(lambda x, y: x * y, ls)

filter

list(filter(lambda x : True if x % 2 == 0 else False, ls))

[0, 2, 4, 6, 8]

sorted

sorted(ls, reverse = True)

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

ls = [0,1,2,3,4,5,6,7,8,9]

ls.sort(reverse = True)

ls

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

ls2 = [(2,4),(1,6),(5,1),(3,8)]

sorted(ls2, key=lambda x:x[0], reverse=True)

[(5, 1), (3, 8), (2, 4), (1, 6)]

sorted(ls2, key=lambda x:x[1],reverse=False)

[(5, 1), (2, 4), (1, 6), (3, 8)]

Python 核心编程

Python 核心编程

1. 数据类型

1.1 整型 int

1.2 浮点数 float

1.3 布尔类型 bool

1.4 字符串 str

1.5 列表 list

1.6 元组 tuple

1.7 集合 set

1.8 字典 dict

2. 逻辑结构、文件操作

2.1 分支结构和三元表达

2.2 循环和遍历

2.3 目录和路径

2.4 文件操作

3. 函数、类、异常处理

3.1 函数

3.2 类

3.3 异常处理

4. 包和模块、随机数

4.1 包和模块

4.2 随机数

5. 生成器、高阶函数

生成器

高阶函数

相关文章