Python 学习

Python 不用“声明”变量

Python 只有 name 和 object. (其他语言的语境下变量的是面向内存的, 而 py 则直接表示指针)

• name: 标识符 (相比其他语言: 变量名)
• object: 变量本身 (相比其他语言: 对象)

a = 3
# a 是一个名字 标识符, 3 是一个 object

这个语句并不是赋值，而是干了以下三件事：

1. 创建name a
2. 创建object 3
3. 将name a 关联到 3这个object

所有的数据都用object（对象）表示。
并不直接使用object，而是使用name的间接方式。
一个object可以被多个name关联。

name 有以下特性：

• name 在创建时必须关联到一个 object。
• name 可以在创建以后指向任何一个 object（包括不同类型）。
• 所以 name 本身没有类别，他关联的 object 是有类别的。
• 可以使用 type(name) 来查看 name 关联的 object 的类型。

其他语言的等号是赋值，而 python 中的等号仅仅是关联 (当前 namespace 没有这个 name 就创建)

python 更关注与数据对象的操作，而不是数据存储。这使得编程者能快速的实现想法，而不过多专注于存储细节 (其实变量在物理上的数据结构是一样的)

object 有以下特性：

• 具有唯一标识，不可改变，通过 id(obj) 查看。
• 类型，不可改变。
• 值，根据类型形式分为mutable（可变：list dict etc.），immutable (不可变：numbers etc.)

btw:

• 不允许使用关键字作为标识符, 如 raise、elif、in、as、except、assert、from、nonlocal
• 不允许使用自带函数名作为标识符, 如 sum、len

原因

上面是我刚摸索时自己想出来的, 其实这些早就有官方文字描述: python 是一门强类型、动态类型的语言

• 简单介绍
  举例来说, python 和 js 都是动态类型语言, 细分下 js 是弱类型语言, python 是强类型语言 (强类型代表类型安全、严谨)
• 什么是弱类型
  弱类型定义的语言, 某一个变量被定义类型, 该变量可根据环境变化自动转换, 不需要强制转换 (隐式类型转换)
• 什么是动态类型
  动态性语言是指在运行期间才去做数据类型检查的语言, 也就是说动态类型语言编程时, 永远不用给任何变量指定数据类型, 该语言会在第一次赋值给变量时, 在内部将数据类型记录下来. Python 和 其他的各种脚本语言如 VBScript 都是动态类型语言
• 动态语言与静态语言的根本不同
  数据类型检查是在运行期间还是编译期间 (python 就是在 运行期间类型检查 和记录的) , js 也在向 ts (静态类型) 发展

ps: 其实性能有些时候并不那么重要, 在达到一定规模时, 性能发挥的作用才会发挥出来

3种占位符

>>> a = 'rose'
>>> b = 'jack'
>>> print("Hi, I'm %s, you're %s." % (a,b))
>>> print("Hi, I'm {}, you're {}.".format(a,b))
>>> print(f"Hi, I'm {a}, you're {b}.")

Hi, I'm rose, you're jack.

• type(a)展示variable的;
• repl: read eval print loop(读取-求值-输出-循环) 交互式解释器 https://repl.it
• yield a，即不会退出的return;

fruit = ['apple','pear','pineapple','orange','banana']
filtered_fruit = [x for x in fruit if x.startswith('a')]
print(filtered_fruit)

['apple']

# 枚举
for i,x in enumerate(fruit):  # 会加索引
    print(i,x)

for i,x in enumerate(reversed(fruit)): # 倒序
	print(i,x)

# Sort會修改原數組，sorted會產生新的
for i,x in enumerate(sorted(fruit)): # 排序
	print(i,x)

# 字典合并与unpacking
>>> a = {"rose": "123456", "xiaoming": "abc123"}
>>> b = {"lilei": "111111", "zhangsan": "12345678"}
>>> c = {**a, **b}
>>> print(c)
{'rose': '123456', 'xiaoming': 'abc123', 'lilei': '111111', 'zhangsan': '12345678'}

# ternary operator 三元
>>> score = 99
>>> print("pass" if score > 60 else "fail")

# sequence unpacking 序列解包（一系列元素 list, tuple, range, ...）
>>> name = "San Zhang"
>>> first_name, last_name = name.split()

# with statement（with 语句之后的代码执行完了，这个文件就会被python自动关闭）
>>> f = open("somefile.txt","r")
>>> s = f.read()
>>> f.close   # 不使用 with 语句，必须手动关闭

>>> with open("somefile.txt", "r") as f:
>>>		s = f.read()  # 自动关闭

4 种生成前 n 个整数列表的方法

## 性能测试
from timeit import Timer

# 循环连接列表 (+) 方式
def test1():
    l = []
    for i in range(1000):
        l = l + [i]
# append 方法添加元素方式
def test2():
    l = []
    for i in range(1000):
        l.append(i)
# 列表推导式方法
def test3():
    l = [i for i in range(1000)]
# range 函数调用转成列表方式
def test4():
    l = list(range(1000))

## 使用timeit模块来对函数计时
# 创建一个Timer 对象, 指定 反复运行的语句 和 只需要运行一次的安装语句
t1 = Timer("test1()", "from __main__ import test1")
# 调用该对象的 timeit 方法, 指定重复次数 number, 返回时间
print("concat ",t1.timeit(number=1000), "milliseconds")
t2 = Timer("test2()", "from __main__ import test2")
print("append ",t2.timeit(number=1000), "milliseconds")
t3 = Timer("test3()", "from __main__ import test3")
print("comprehension ",t3.timeit(number=1000), "milliseconds")
t4 = Timer("test4()", "from __main__ import test4")
print("list range ",t4.timeit(number=1000), "milliseconds")

结论:
concat < append < comprehension (列表推导式) < list range

1. concat 最慢, List range 最快 (相差近 200倍)
2. append 也比 concat 快
3. 列表推导式 (comprehension) 速度是 append 两倍

列表的复制生成

在 python 中, 如果用一个列表 list1 乘一个数字 n 会得到一个新的列表 list2, 这个列表的元素是 list1 的元素重复 n 次

list1 = [0]
list2 = list1 * 5		# list2 = [0, 0, 0, 0, 0]

如果此时 list1 内含有引用类型, 需注意值传递

有趣的是列表连接的方式 (+) 也能混用

In [2]: [1] + [2] * 2
Out[2]: [1, 2, 2]

# ps: 不支持减法
In [5]: [1] + [2] - [2]
TypeError: unsupported operand type(s) for -: 'list' and 'list'

函数嵌套 (函数的嵌套定义)

def func(a, b):
    c = 1024
    def foo(b, d):
        print(b, d, c, a) # b、d 是内部方法参数, c、a 是借用外部的
    return foo(a, b) # 先执行函数调用
a = func(4, 7)
print(a)

"""
输出:
4 7 1024 4
None
"""

常用操作

list[4:6]  左闭右开

# 本类实例调用必须加 self. (貌似是为了区分全局和实例)

list.index(x[, start[, end]]) # x-- 查找的对象 start-- 可选，查找的起始位置 end-- 可选，查找的结束位置

常用的 Python 数据科学和机器学习库的介绍

NumPy, Pandas, PyTorch, Scikit-Learn, TensorFlow , Keras, Matplotlib, Seaborn

1. NumPy
   功能：提供支持大规模多维数组和矩阵的运算，配有大量的数学函数。
   特点：高性能，便于进行数值计算和数组操作。
2. Pandas
   功能：用于数据操作和分析，提供数据结构如 DataFrame 和 Series。
   特点：强大的数据处理功能，适合时间序列分析和数据清洗。
3. Scikit-Learn
   功能：机器学习库，提供简单高效的工具用于数据挖掘和数据分析。
   特点：支持分类、回归、聚类等多种机器学习算法，易于使用。
4. TensorFlow
   功能：一个开源深度学习框架，适用于构建和训练神经网络。
   特点：支持大规模的机器学习和深度学习模型，具有强大的计算图和分布式计算能力。
5. Keras
   功能：高层API，构建在 TensorFlow 之上，简化深度学习模型的构建和训练。
   特点：用户友好，适合快速实验和原型开发。
6. PyTorch
   功能：深度学习框架，提供动态计算图和强大的张量计算。
   特点：灵活性高，尤其在研究和原型开发中受欢迎。
7. Matplotlib
   功能：用于数据可视化，能够创建静态、动态和交互式图表。
   特点：功能强大，支持多种图形格式。
8. Seaborn
   功能：基于 Matplotlib 的数据可视化库，提供更美观的统计图表。
   特点：简化了复杂数据的可视化，支持多种主题和调色板。