From 11850cbb513a21cbcd070b4d056bbd5a12fcb717 Mon Sep 17 00:00:00 2001
From: asahi <mikiyashiki@outlook.com>
Date: Fri, 3 May 2024 20:52:04 +0800
Subject: [PATCH] =?UTF-8?q?=E9=98=85=E8=AF=BBpython=E6=96=87=E6=A1=A3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 python/py.md | 484 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 484 insertions(+)
 create mode 100644 python/py.md

diff --git a/python/py.md b/python/py.md
new file mode 100644
index 0000000..2f780ca
--- /dev/null
+++ b/python/py.md
@@ -0,0 +1,484 @@
+# Python
+## 变量
+在python中，可以通过如下方式创建变量：
+```python
+message = "Hello Python Crash Course world!"
+```
+## 字符串
+### 字符串首字母大写
+```python
+name = "ada lovelace"
+print(name.title())
+```
+### 字符串全部字符大写
+```python
+name = "Ada Lovelace"
+print(name.upper())
+```
+### 字符串全部字符小写
+```python
+name = "Ada Lovelace"
+print(name.lower())
+```
+### 字符串删除空白符
+```py
+name = " Asahi Ogura    `
+# 删除左空白 
+name.lstrip()
+# 删除右空白
+name.rstrip()
+# 删除左右空白
+name.strip()
+```
+### 访问字符串中字符
+ptyhon可以通过数组下标来访问字符串中的字符，如果字符串长度为n，那么索引范围为`[0, n-1]`，同时，在python中还可以使用负数的索引，索引范围为`[-n, -1]`。
+
+在python字符串中，第一个字符可以通过索引下标`0`和`-n`来访问，最后一个字符可以通过`n-1`和`-1`来访问。
+
+### 字符串切片
+字符串切片可以通过`str[from:to:step]`来标识，其标识下标为`[from, to)`范围内的子字符串，步长为`step`。
+
+```py
+temp = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+```
+
+其中，输出`[0,10)`范围内的字符串可以采用如下方式：
+```py
+print(temp[0:10])  # ABCDEFGHIJ
+print(temp[0:10:1]) # ABCDEFGHIJ
+```
+
+当步长被设置为2时，输出内容如下：
+```py
+print(temp[0:10:2]) # ACEGI
+```
+
+正数索引和负数索引混用：
+```py
+# 输出不包含末尾2个字符的子字符串
+print(temp[0:-2]) # ABCDEFGHIJKLMNOPQRSTUVWX
+print(temp[0:24]) # ABCDEFGHIJKLMNOPQRSTUVWX
+print(temp[:-2]) # ABCDEFGHIJKLMNOPQRSTUVWX
+
+# 输出末尾两个字符的子字符串
+print(temp[-2:])
+```
+逆序输出字字符串
+```py
+print(temp[::-1]) # ZYXWVUTSRQPONMLKJIHGFEDCBA
+print(temp[-1:0:-1]) # ZYXWVUTSRQPONMLKJIHGFEDCBA
+print(temp[25:0:-1]) # ZYXWVUTSRQPONMLKJIHGFEDCBA
+```
+### 字符串迭代
+python中字符串可迭代，示例如下：
+```py
+temp = "ABCDE"
+for ind, ch in enumerate(temp):
+    print("ind = "+str(ind)+", ch = "+ch, end="\n")
+
+# ind = 0, ch = A
+# ind = 1, ch = B
+# ind = 2, ch = C
+# ind = 3, ch = D
+# ind = 4, ch = E
+```
+
+## 数字
+### /
+python中，整数执行`/`操作默认并不会进行整除，而是可能生成浮点数
+```py
+print(3/2) # 1.5
+```
+
+### //
+python中，如果要执行整除，应该使用`//`运算符，该运算符为向下取整
+```py
+print(3//2) # 1
+print(-3//2) # -2
+```
+> 和java不同，java在执行整数除时，会舍弃掉小数部分，例如`-3/2`，java中结果为-1，而python则是向下取整为-2
+>
+> 如果python中`/`操作想要和java保持一直，可以使用math中的`trunc`函数，`math.trunc(-3/2)`返回结果和java中一样，为`-1`
+
+### 数字类型向字符串类型转换
+可以通过str函数将数字类型转化为字符串类型
+```py
+temp = 1.2
+print("temp = "+str(temp))
+```
+
+## 列表
+python中通过`[e1, e2, ...]`的形式来标识列表
+
+### 访问列表中元素
+可以通过数组下标的方式来访问列表中的元素
+```py
+temp = [1, "2", "san"]
+
+print(temp[1]) # 2
+print(temp[-2]) # 2
+```
+
+### 列表元素操作
+#### 修改
+```py
+temp = [1, "2", "san"]
+
+temp[2] = 3.0
+print(temp) # [1, '2', 3.0]
+```
+
+#### 插入到末尾
+如果想要向数组末尾插入元素，可以调用append方法
+```py 
+temp = [1, "2", "san"]
+
+temp.append("four")
+print(temp) # [1, '2', 'san', 'four']
+```
+#### 在某位置之前插入
+如果想要在特定位置之前插入元素，可以调用insert方法
+```py
+temp = [1, "2", "san"]
+
+temp.insert(1, "1.5")
+print(temp)  # [1, '1.5', '2', 'san']
+temp.insert(4, "four")
+print(temp)  # [1, '1.5', '2', 'san', 'four']
+```
+#### 删除列表中的元素
+如果想要删除列表中的元素，可以通过del关键字进行删除
+```py
+temp = [1, "2", "san"]
+
+del temp[1]
+print(temp) # [1, 'san']
+```
+
+#### 列表与栈api
+列表append操作是将元素追加到列表末尾，同时列表还支持pop操作，将列表末尾的元素作为栈顶元素弹出。
+
+如果此时列表为空，那么调用pop方法将抛出异常
+
+```py
+temp = [1, "2", "san"]
+
+
+print(temp.pop())  # san
+print(temp.pop())  # 2
+print(temp.pop())  # 1
+print(temp.pop())  # IndexError: pop from empty list
+```
+
+还可以为pop方法指定一个下标，此时可以弹出任何位置的元素
+```py
+temp = [1, "2", "san"]
+
+
+print(temp.pop(1)) # 2
+print(temp.pop(0)) # 1
+print(temp.pop(0)) # san
+```
+#### remove
+在列表中，可以调用remove来移除列表中值为xxx的元素。
+
+remove默认只会移除第一个匹配的元素
+```py
+temp = [2, 1, 2, 1, 2]
+
+temp.remove(2)
+print(temp) # [1, 2, 1, 2]
+```
+
+### 列表排序
+#### sort
+可以通过sort方法针对列表中的元素进行排序，sort方法会该表列表中的元素顺序
+```py
+temp = [2, 1, 2, 1, 2]
+
+temp.sort()
+print(temp) # [1, 1, 2, 2, 2]
+```
+
+如果想要逆向排序，可以为sort方法指定`reverse=True`
+```py
+temp = [2, 1, 2, 1, 2]
+
+temp.sort(reverse=True)
+print(temp) # [2, 2, 2, 1, 1]
+```
+
+#### sorted
+如果不想改变原列表中的元素顺序，而是生成一个排好序的新列表，可以调用sorted函数
+```py
+temp = [2, 1, 2, 1, 2]
+
+print(sorted(temp)) # [1, 1, 2, 2, 2]
+print(sorted(temp, reverse=True)) # [2, 2, 2, 1, 1]
+print(temp) # [2, 1, 2, 1, 2]
+```
+
+### 列表中顺序反转
+如果不想对列表中元素进行排序，只是想逆序列表中的数据，可以调用reverse方法
+```py
+temp = [2, 1, 2, 1, 3]
+
+temp.reverse()
+print(temp) # [3, 1, 2, 1, 2]
+```
+### 获取列表长度
+可以通过len函数获取列表的长度
+```py
+temp = [1,2,3]
+
+temp.pop()
+print(len(temp)) # 2
+temp.pop()
+print(len(temp)) # 1
+temp.pop()
+print(len(temp)) # 0
+```
+
+### 遍历列表
+在python中，可以通过`for ... in ...`的形式来遍历列表中的元素
+```py
+temp = [1, 2, 3]
+
+for e in temp:
+    print(e)
+
+# 1
+# 2
+# 3
+```
+
+### range
+在python中，可以通过range函数生成一系列数字，`range(m,n)`会生成`[m,n)`范围内的数字，可用于`fori`形式的遍历
+```py
+arr = ["1", "3", "2"]
+
+for ind in range(0, len(arr)):
+    print(arr[ind])
+
+# 1
+# 3
+# 2
+```
+可以通过range函数来创建数字列表
+```py
+print(list(range(0, 5))) # [0, 1, 2, 3, 4]
+```
+
+range也可以指定步长
+```py
+print(list(range(0, 7, 2))) # [0, 2, 4, 6]
+```
+
+### max, min, sum
+针对数字型的列表，支持max、min、sum等函数来求最大值、最小值、总和
+```py
+arr = list(range(1, 101))
+
+print(max(arr)) # 100
+print(min(arr)) # 1
+print(sum(arr)) # 5050
+```
+### 根据一个列表生成另一个列表
+python中，根据`[expr(e) for e in list_a]`的语法，可以快速根据一个列表得到应一个列表，目标列表中的每个元素都来源于来源列表的映射
+```py
+arr = ['amd', 'nvidia']
+graphic_msgs = ['fuck '+brand for brand in arr]
+print(graphic_msgs) # ['fuck amd', 'fuck nvidia']
+```
+
+### 切片
+列表的切片和字符串切片类似
+```py
+arr = [1, 2, 3, 4, 5]
+print(arr[::2]) # [1, 3, 5]
+
+print([e**2 for e in arr[::2]]) # [1, 9, 25]
+```
+
+### 列表复制
+在python中，如果要复制列表，可以创建整个列表的切片
+```py
+arr = [1, 2, 3]
+# 复制列表
+arr_copied = arr[:]
+
+print(arr_copied) # [1, 2, 3]
+
+# 对复制后的列表进行写操作，并不会影响复制前的列表
+arr_copied.pop()
+
+print(arr_copied) # [1, 2]
+print(arr) # [1, 2, 3]
+```
+
+## 元组
+运行时列表中的元素可以被修改，如果想要让元素不可变，可以使用元组。
+
+元组通过`(e1, e2, e3, ...)`形式来表示，和列表一样，元组也可以通过索引来访问。
+
+但是元组中的元素无法复制，在执行赋值语句时会抛出异常。
+```py
+pos = (50, 100)
+
+pos[0] = 125 # TypeError:'tuple' object does not support item assignment
+```
+
+## if
+类似其他编程语言，python也支持if/else语法
+```py
+cars = ['audi', 'bmw', 'subaru', 'toyota']
+for car in cars:
+    if car == 'bmw':
+        print(car.upper())
+    else:
+        print(car.title())
+```
+
+### and/or
+python可以通过`and`和`or`操作符来拼接多个条件。
+```py
+age = 179
+is_alive = True
+
+if age < 0 or age > 150 and is_alive:
+    print("age wired")
+```
+
+### 列表中是否包含某值
+如果想要检查列表中是否包含特定值，可以采用`xxx in list_a`的语法。
+```py
+arr = [1, 3, 2]
+
+print(1 in arr) # True
+```
+### 列表中是否不包含某值
+如果想要检查列表中是否不包含特定值，可以采用`xxx not in list_a`的语法。
+```py
+arr = [1, 3, 2]
+
+print(1 not in arr) # False
+```
+
+### 多分支if/elif/else
+python可以通过if/elif/else的语法实现多分支判断
+```py
+age = 40
+if age < 20:
+    print("teen")
+elif age < 40:
+    print("man")
+else:
+    print("elder man")
+```
+
+## 字典
+在python中，通过字典实现了其他语言中的Map数据结构。
+
+```py
+dic = {"name": "Ogura Asahi", "age": 17}
+
+print(dic['name']) # Ogura Asahi
+```
+### 向字典中添加键值对
+```py
+dic = {"name": "Ogura Asahi", "age": 17}
+
+dic['major'] = "student"
+print(dic) # {'name': 'Ogura Asahi', 'age': 17, 'major': 'student'}
+```
+
+### 删除字典中的键值对
+```py
+dic = {"name": "Ogura Asahi", "age": 17}
+
+del dic['age']
+print(dic) # {'name': 'Ogura Asahi'}
+```
+
+### 字典遍历
+字典遍历可以通过`for k, v in dic.items()`的形式完成
+```py
+dic = {"name": "Ogura Asahi", "age": 17}
+
+for key, val in dic.items():
+    print("key = "+key+" , value = "+str(val))
+```
+如果只想遍历字典的key集合，可以通过`for k in dic.keys()`的方式
+```py
+dic = {"name": "Ogura Asahi", "age": 17}
+
+for key in dic.keys():
+    print("key = "+key)
+```
+如果只想遍历字典的value集合，可以通过`for v in dic.values()`的形式
+```py
+dic = {"name": "Ogura Asahi", "age": 17}
+
+for value in dic.values():
+    print("value = "+str(value))
+```
+### 按顺序遍历字典的key
+通常，字典的key遍历顺序是不一定的。如果想要按排序后的顺序遍历key，可以采用如下方式：
+```py
+dic = {"name": "Ogura Asahi", "age": 17}
+
+for key in sorted(dic.keys()):
+    print("key = "+str(key))
+```
+## while
+```py
+i = 0
+
+while i < 10:
+    print(i)
+    i += 1
+```
+## 函数
+函数可通过如下方式来定义：
+```py
+def fuck(brand, boss):
+    print("fuck you " + boss + " and your " + brand)
+
+
+fuck("Nvidia", "Jensen Huang")
+```
+
+在调用函数时，可以打乱传入实参顺序，只需要传参时指定参数名称即可：
+```py
+def fuck(brand, boss):
+    print("fuck you " + boss + " and your " + brand)
+
+
+fuck(boss="Jensen Huang", brand="Nvidia")
+```
+### 参数默认值
+声明函数时，可以为参数指定默认值，故而在调用函数时，可以对有默认值的参数进行省略
+```py
+def fuck(boss, brand="Nvidia"):
+    print("fuck you " + boss + " and your " + brand)
+
+
+fuck("Jensen Huang")
+fuck(brand="Apple", boss="Cook")
+```
+### 接收多个参数
+通过`*paramTup`的形式，python会将函数接收到的参数都存储在一个元组中。
+```py
+def fuck(*name_list):
+    msg = "fuck "
+    is_head = True
+    for name in name_list:
+        if not is_head:
+            msg += ", "
+        is_head = False
+        msg += name
+    print(msg)
+
+
+fuck("Nvidia", "Amd")
+```
\ No newline at end of file