(1) python数据类型

(一) 笔记介绍

这里是python的深度学习版本，主要是针对深度学习进行。这里面可能需要一点点的编程基础，不然节奏可能会有一些快。

如果有兴趣的话可以看看我之前的文章学习python的入门版
【1】https://www.jianshu.com/p/ccca2c506856

（1）搞科研为什么选择python？

选择其他的语言也可以，但是我们在进行科学研究的过程中对数学的以来较高。
然而python用有大量的数学库，使用起来极其方便。例如高维数据的处理，矩阵运算等

（2）强类型，弱类型

强类型语言：java、C/C++；需要提前进行编译，必须指定类型（int a=3;）
弱类型语言：js、python；解释性语言，无需指定类型（a=1）

（3）课程中所需的软件

• anaconda：一个开源的python发行版本包括了conda，python等多个科学包及其依赖。
• pycharm/vscode:用于写代码。

（二）数据类型

（1）变量和标量

• 变量：计算机里面的一块内存空间 a=1
• 标量：不可改变的量

变量名（标识符）的要求：由字母数字下滑线组合，区分大小写。不能以数字开头，不能使用python保留字（关键字）。

（2）数据类型

• number（数字）：（int, float, bool, complex(复数)）
• string（字符串）：单引号，双引号，三引号表示的一串字符。
• dictionary（字典）：键值对。
• set（集合）：没有重复元素，无序
• tuple（元组）：一个连续空间；值在定义后不可改变；
• list（列表）：一个值可以改变的连续空间

python由于是弱类型的语言，他不要求在定义的时候指定类型，所以在编译的时候会自动类型推导。

不可变数据类型：Number，string，tuple
可变数据类型：list，dictionary，set

# 六种数据类型
print(type(1)) # <class 'int'>
print(type([1,2])) # <class 'list'>
print(type((1,2))) # <class 'tuple'>
print(type({"1":1,"2":2})) # <class 'dict'>
print(type({"1","2"})) # <class 'set'>
print(type("12")) # <class 'str'>

# 类型转换
print(1+2.0) # 隐式类型转换 3.0
print(float("123")) # 显式类型转换 123.0
print(ord("1")) # 转化为ascll码 49

# 变量赋值
a = 1
b = c = a 
d, e, f = 2,3,4
print(a,b,c,d,e,f) # 3 1 1 1 2 3 4

# 不可变数据类型
str = "abc"
str[1] = "c" # TypeError: 'str' object does not support item assignment

# 可变数据类型
lst = [1,2,3]
lst[1] = 4

(3)运算符

常用运算符：

• 算术运算符：+, -, *, /, %(取模), //(向下取整), **（指数）
• 比较运算符：==, !=, >, <, >=, <=
• 赋值运算符：=, +=, -=, :=(海象运算符)
• 逻辑运算符：and, or, not

运算符优先级：
一般我们只需要知道()的运算优先级最高，如果我们不知道运算符，我们加个（）就好了。

1. 括号：()
2. 幂运算：**
3. 按位取反：~
4. 正号、负号：+、-
5. 乘、除、取模、取整除：* 、/、 %、 //
6. 加、减：+ 、-
7. 右移、左移：>> 、<<
8. 按位 “与”：&
9. 按位 “异或”，按位 “或”：^ 、|
10. 比较运算符：<= 、< 、>、 >=
11. 等于、不等于：==、!=
12. 赋值运算符：=、%=、/=、//=、-=、+=、=、*=
13. 身份运算符：is、is not
14. 成员运算符：in、not in
15. 逻辑运算符：and or not

x=3
print(3%4) # 3
print(3//4) # 0
print(3**4) # 81
print(3==4) # False
print(3 and 4) # 4
print(True and False) # False
x+=4
print(x) # 7

# 海象运算符，可以在表达式内部给变量赋值,需要python版本>=3.8
if (n=10) > 5: # SyntaxError: invalid syntax
    print(n)
    print(123)

if (n:=10) >5:
    print(n) # 10
    print(123) # 123

(4) str字符串和可变字符串(StringIO)

• str字符串

<1> str字符串拼接，直接使用+，加号两边都要是str类型。
<2>可以使用字符串格式化的方法对输出的文字进行拼接。（具体看代码）
<3>使用字符串索引获取值

• StringIO 可变字符串

<1> 上面我们说过string类型的字符串是不可变类型的，我们如果需要修改其中的一个字符的时候是不允许的。于是python提出了可变字符串。
<2>stringIO是一个class，可以直接在内存中修改值。而不需要重新分配内存空间。所以运行效率相对更高一些。

str = "123"+"234"
print(str) # 123234

# 字符串格式化
print("1234%s%s" % ("567","890")) # 1234567890
print("1234{0}{1}".format("567","890")) # 1234567890
print("1234{first}{second}".format(first="567",second="890")) # 1234567890
print(f"1234{'567'}{'890'}",) # 1234567890

# 索引(开始：结束：步长) 取值区间左闭右开
print(str[0:4]) # 1232
print(str[0:4:2]) # 13
print(str[::] == str[:]) # True
print(str[::-1]) # 432321
print(str[-1:-4:-1]) # 432
print(str[20]) # IndexError: string index out of range

from io import StringIO 
import time 

begin_time = time.time()
sio = StringIO("123")
sio.seek(3) # 等价于sio.seek(0,2)
for i in range(90000):
    sio.write("_") # 需要改变指针位置否则会覆盖初始值
end_time =  time.time()

print("used time:", end_time-begin_time) # 0.01501321792602539
# print(sio.getvalue())

begin_time = time.time()
str = "123"
for i in range(90000):
    str+="_"
end_time =  time.time()

print("used time:", end_time-begin_time) # 0.02902507781982422
# print(str)

（5）列表

列表是一块连续的内存空间，里面的的值可以是任何基本数据类型。
我们可以使用索引来查看元素，使用append()方法在数组末尾添加元素。
还可以使用insert()方法在指定位置插入元素.
使用del关键字删除指定元素。
使用pop()删除最后一个元素。
使用reverse()将列表反转。
使用sort()将列表排序，字典序。
使用max()返回最大值。
使用min()返回最小值。
使用copy()深度拷贝,赋值不是深拷贝。
使用运算符对列表进行拼接、复制n次、查找成员。

元组就是值不能改变的数组。

list1 = ["a", "b", "c"]
list2 = [1,2,3]
list3 = ["a", 2, "b"]
print(list1, list2, list3) # ['a', 'b', 'c'] [1, 2, 3] ['a', 2, 'b']
print(list1[0]) # a
print(list1[0][0]) # a
print(list1[0:2]) # ['a', 'b']
list1.append(3)
print(list1) # ['a', 'b', 'c', 3]
list1.insert(4,4)
print(list1) # ['a', 'b', 'c', 3, 4]
del list1[3]
print(list1) # ['a', 'b', 'c', 4]
list1.pop()
print(list1) # ['a', 'b', 'c']
list1.reverse()
print(list1) # ['c', 'b', 'a']
list1.sort()
print(list1) # ['a', 'b', 'c']
list4 = list1.copy()
print(id(list1),id(list4)) # 2990319818240 2990319729472
list5 = list1
print(id(list1),id(list5)) # 2990319818240 2990319818240

print(list1+list2) # ['a', 'b', 'c', 1, 2, 3]
print(list1*2) # ['a', 'b', 'c', 'a', 'b', 'c']
print("a" in  list1) # True

for i in list1:
    print(i)

# 列表嵌套
list1.append(list2)
print(list1) # ['a', 'b', 'c', [1, 2, 3]]

t1 = tuple(list1)
print(t1) # ('a', 'b', 'c', [1, 2, 3])

(6) 集合

set和数学中集合的概念一致，元素无序且唯一。
使用add()来向集合中添加元素。
使用update添加多个元素。
使用remove删除指定元素。
使用discard删除指定元素,不报错。
使用pop删除随机元素。

set1 = {"a","a","a","a","a","a","a","a","b","c"}
print(set1) # {'b', 'a', 'c'}
# print(set1[0]) # TypeError: 'set' object is not subscriptable
set1.add("a")
print(set1) # {'b', 'a', 'c'}
set1.add("d")
print(set1) # {'d', 'b', 'a', 'c'}
set1.update({"1","2","3"})
print(set1) # {'d', '2', 'b', 'a', 'c', '1', '3'}
set1.remove("d")
print(set1) # {'2', 'b', 'a', 'c', '1', '3'}
set1.discard("dd")
print(set1) # {'2', 'b', 'a', 'c', '1', '3'}
set1.pop()
print(set1) # {'b', 'a', 'c', '1', '3'}
set2 = set1.union({"3","4","5"})
print(set2) # {'4', 'b', 'a', 'c', '1', '3', '5'}
set3 = set2.intersection({"3","4","5","6"})
print(set3) # {'4', '3', '5'}

(7)字典

字典的存储方式是键值对，键必须是唯一的（否则会被覆盖），但是值可以是不同的。
添加键值对得方法更加简单直接和复制一样，python发现字典里没有该项，会自动添加进去。
使用del关键字删除指定元素。
使用get关键字获取元素。
使用keys关键字获取所有元素的键。
使用values关键字获取所有元素的值。

sun = {"age":18,"sex":"男","a":"A"}
print(sun)
print(sun["age"])
sun["age"] = 19
sun["adress"] = "花果山"
print(sun) # {'age': 19, 'sex': '男', 'a': 'A', 'adress': '花果山'}
del sun["a"]
print(sun) # {'age': 19, 'sex': '男', 'adress': '花果山'}
print(sun.get("test")) # None
print(sun["test"]) # KeyError: 'test'
print(sun.keys()) # dict_keys(['age', 'sex', 'adress'])
print(sun.values()) # dict_values([19, '男', '花果山'])

# 循环迭代
for key in sun:
    print(sun[key])

print("age" in sun) # True