【Python】基本数据类型

数字类型

int
long
float
bool
complex

整数类型

整数类型没有取值范围的限制

0x或0X开头表示16进制
0b或0B开头表示2进制
0o或0O表示8进制

str(1) #数字转字符
int('1') #字符转数字 int
float(x) #转换成一个浮点数
complex(x) #转换成复数

进制转换

int('51',base=14) #把base进制表示字符串，转为十进制
bin(2)   # 整数转二进制 '0b10'
oct(8)   # 整数转八进制 '0o10'
hex(31)   # 整数转十六进制 '0x1f'
ord("A") #字符转ascii码
chr(97)  #ascii码转字符

四舍五入

round(x) # 返回 int
round(x, 0) #截取相应的位数，返回float
math.trunc#  向0取整
math.ceil
math.floor

其它基本运算符

abs(-2) # 2
divmod(11,3) # (3, 2)
pow(x,y)
pow(x, y, z)  # 相当于 x**y % z

浮点类型

带小数点或小数的数字

精度有限制 float信息：
```
import sys
sys.float_info
```

复数类型

虚数部分用j或J表示，例如：

12.3+4j,
z=1.23e-4+5.6e+89j
z.real   z.imag    

转化：

int(a) # 直接去掉小数部分
float(a) # a不能是复数
complex(a)

type(x) 返回类型

tuple

特点

元组中的元素可以是不同类型的
```
t3=123,456,("hello","中国")
```
tuple定义之后，其中的元素不能更改，也不能删除
如果tuple中有个list，这个list可以更改

生成

x=(1,2,3)
x=1,2,3 # 不加括号也能生成 tuple
x=1, # 包含一个元素的 tuple

方法

x+y
3*x
x[::2]

特性

y=[5,6,7]
x=(1,2,y)
x[2][0]=1000
y[1]=800

list

方法

x+y#连接起来
int*x #重复n次
len(x)
x[::2]
for i in x
exp in x#返回逻辑值，判断exp是否在x中

# 取出 list 中的元素
lst = [1, 2, 3, 4, 5]
a, *b, c = lst
*a, b = lst
a, *b = lst

切片

索引从0开始计数，

-1是末尾，-2是倒数第二个

helloString='hello world'
helloString[1:3]
helloString[4:] # 4到末尾
helloString[:-2]
helloString[::2] # 按照步长取字符
helloString[::-1]

以下几个方法，直接改变list，而是不返回list

<list>.append(x)   # 把x作为一个元素放到<list>的末尾
<list>.extend(c)   # 把c中的元素添加到list中，c是集合、list、tuple等
<list>.insert(i,x) # 在i位置插入x

del x[1]           # 直接删除
del x[::-2]
<list>.remove(x)  # 删除list中第一次出现的元素x，如果没找到会抛出异常
<list>.pop(i)     # 返回list中第i个元素，并从list中删除，如果不给参数，指的是最后一个


<list>.sort()     # 排序，返回none
#b=['123','2','33']
#b.sort(key=int,reverse=False)

<list>.reverse()  # 元素反转,返回none
<list>.index(x)   # 返回第一次出现x的索引位置
<list>.count(x)   # 返回x在列表中的数量

enumerate迭代器

String1 ='hello world'
for index,letter in enumerate(String1):
    print(index,letter)
for i in enumerate(String1)
    print(i) # i是tuple类型

此外，enumerate也可以用于list

zip/unzip

a = [1, 2, 3, 4]
b = ['a', 'b', 'c']
list(zip(a,b)) # [(1, 'a'), (2, 'b'), (3, 'c')]
dict(zip(a,b)) # {1: 'a', 2: 'b', 3: 'c'}
# a, b的长度可以不一样，这样就是取最短的

unzip:

a=[(1, 'a'), (2, 'b'), (3, 'c')]
list(zip(*a)) # [(1, 2, 3), ('a', 'b', 'c')]

range

range(start, stop, step)

dict

Python对存储顺序进行了优化
list的key是数字，dict的key可以是任何类型的不可变对象（例如，数字、字符、元组）
dict排列无序，list有序
值可以是任何类型
命名空间是通过字典来实现的

创建

# 构造方法1:
d={"key1":"value1","key2":"value2"}

# 构造方法2：
d = dict()
d = dict(key1=value1, key2=value2) # key的名字不用是字符串
d = dict([('name','tom'), ('age',22)])

# 构造方法3：
keys = ['name','age']
values = ['tom', 22]
d = dict(zip(keys,values))

修改

d["key3"] = 5 # 新增一对key-value，如果有key那么是修改
d.update(<dict>) # 新增key-value，如果key已经存在则修改

del(d["key3"]) # 删除一对key-value
d.clear() #清空dict
d.pop('key1') # 返回key1对应的value，并且从d中删除key1。不存在则报错
d.pop('key1','not exist') # 不存在则返回'not exist', 而不是报错

d.popitem() # 返回一对 key-value，并将其从字典移除

d.clear() # 清除字典，返回 None

遍历

for key in my_dict:print(key) #key是str
for key in my_dict.keys():print(key) #key是str, my_dict.keys()是<dict_keys>类
for value in my_dict.values():print(value) #value是各自的类，my_dict.values是<dict_name>类
for k in my_dict.items():print(k) #k是tuple,里面放着一对key-value;my_dict.items()是<dict_items>类
for key,value in my_dict.items():print(key,value)

查询

<dict>.keys() # 返回所有key
<dict>.values() # 返回所有value
<dict>.items() # 返回key-value
<dict>.get(key) # key对应的value，不存在返回 None，而不是报错
<dict>.get(key,val) # 不存在则返回 val，而不是报错

取值

x['bill'] # 取值
len(x); # 求长度
'bill' in x; #返回 Ture or False

dict1= sorted(word_dict.items(), key=lambda d:d[1], reverse = True)

set

集合是可变的，frozenset 是不可变的

集合运算

z1=x.intersection(y) # 交
z2=y.union(x) # 并
z3=y.difference(x) # 差

a.issebset(b) # a是否是b的子集
a.issuperset(b)

a.isdisjoint(b) # 是否有交集

或者：

a & b  # 交
a | b  # 并
a - b  # 差
a ^ b  # 补 =x|y-x&y

a == b  # 相等
a > b  # 真超集
a >= b  # 超集
a < b  # 真子集
a <= b  # 真超集

此外，还支持update类操作，例如：

a -= b
a ^= b

方法

a.add(9) # 添加一个元素
a.update([1,2,3,4]) #把iterable object中的元素作为元素

a.remove(4) #删除一个元素，不存在则报错

互转

x可以是tuple，list，set：

tuple(x)
list(x)
set(x)

关于引用

一些“特性”

sum([0.1 for i in range(10)])==1
# False

效率
与set/dict相比，list擅长内存使用和迭代，不擅长成员检测$(\Theta (lg n))$
list:指定位置修改是$\Theta(1)$
链表：指定位置修改$\Theta(n)$,因为需要遍历，平均遍历半个数据量
list：交换操作是$\Theta(1)$（知道两个元素位置的话） list：插入和删除$\Theta(n)$
链表：插入和删除$\Theta(1)$

3递归引用

p = [1, 2, 3]  
p.append(p)
p in p

结果是 True

4循环引用

a = [1, 2]
b = [3, 4]  
a.append(b)  
b.append(a)  
a in b,b in a

结果是(True, True)

a = [1,2,3]
b = a[:]
c=a
del a

b的值是什么。为什么呢？

可迭代对象

all
any
enumerate
map(func, lst)

其它

locals() # 全部本地对象
globals() # 全部全局对象

# 内存查看对象
memoryview(bytes(string, encoding='utf-8'))

hash:在hash()对对象使用时，所得的结果不仅和对象的内容有关，还和对象的id()，也就是内存地址有关。

class Test:
    def __init__(self, i):
        self.i = i
for i in range(10):
    t = Test(1)
    print(hash(t), id(t))

查看对象的内存

v = memoryview(bytearray("abcefg", 'utf-8'))

# 用字符串的方式导入包，不过不推荐使用
__import__('numpy')

# 这是一个dict，内容是已经加载的包
sys.modules

# 这是一个list，内容是命名空间中所有变量
dir()

with语句

with语句做了什么？

计算表达式的值，返回一个上下文管理对象
加载上下文管理对象的 __exit__() 方法以备后用
调用上下文管理器对象的 __enter__() 方法
如果with语句中设置了目标对象，把 __enter__() 方法的返回值赋值给目标对象
执行 with 中的代码块
如果正常结束，调用 __exit__() 方法，忽略返回值。
如果发生异常，调用 __exit__() 方法，把异常类型、值、traceback信息传递给 __exit__()。如果 __exit__() 返回 True，异常被挂起，程序继续执行；如果返回False，抛出异常。

with语句好处是无论何种方式跳出代码块，__exit__() 总是被执行

你可以定义自己的上下文管理器：

class MyContextManager(object):
    def __enter__(self):
        print('enter')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('leaving', exc_type, exc_val, exc_tb)
        if exc_type is None:
            return False
        if exc_type is ZeroDivisionError:
            print('ZeroDivisionError')
            return True
        print('other error')
        return True

with MyContextManager():
    1/0

else

for循环后面可以跟else，当循环自然终结时，会执行else；如果被break打断，不执行else

for i in range(4):
    print(i)
    if i>5:break
else:
    print('no more then 5')

try 后面跟else，当try语句没发生异常时，执行else，全语句： try-except-else-finnaly

可变对象和不可变对象

class STUDENT:
    def __init__(self, name, course=[]):
        self.name = name
        self.course = course

    def add_course(self, course_name):
        self.course.append(course_name)


Lucy = STUDENT('Lucy')
Lily = STUDENT('Lily')

Lucy.add_course('math')
Lily.add_course('PE')

print(Lucy.course)
print(Lily.course)

很惊讶的发现，虽然 Lucy 和 Lily 是不同的对象，但course却指向同一个地址。这是因为默认参数仅仅评估一次。

配置文件

常见有XML，ini

ConfigParser 是一个常用的解析配置文件的包

getboolean('section1', 'option1') 可以解析 yes/no, true/false, on/off

调试

traceback 来调试报错信息，logging 来记录日志

logger分为五个等级

DEBUG，
INFO，正常的信息
WARNING
ERROR
CRITICAL

import logging

logging.Logger.setLevel()
logging.Logger.addHandler()
logging.Logger.removeHandler()
logging.Logger.addFilter()

logging.Logger.debug()
logging.Logger.info()
logging.Logger.warning()
logging.Logger.error()

一个简单案例

import logging

logging.basicConfig(
    level=logging.DEBUG,
    filename='log.txt',
    filemode='w',
)

k = 0
for i in range(5):
    k += i
    logging.info('[INFO]:calling i={i}'.format(i=i))

类型标注

from typing import List, Tuple, Dict, Union, Optional

def func(inp1: List[float], inp2: List[Tuple], inp3: str = "123") -> int:
    return int(inp3)

func([1, 2, 3], [(2, 3)], "12")

别名

Vec2D = List[List[int]]


def func2(inp: Vec2D):
    pass

参考文献

https://docs.python.org/3/