【Python】Basis

变量

标识符

• 数字、字母、下划线

• 必须以字母或下划线开头，不能以数字开头

• 大小写敏感

• 不能是关键字（保留字）

  • Python2 的关键字：
    

  • Python3 的关键字
    

变量将名字和对象关联起来，赋值操作并不会实际复制值，只是为数据对象取相关名字。名字是对象的引用而不是对象本身。

小整数（-5 ～ 256）直接作为对象存储，地址固定，而其他的整数地址要临时分配

a = 7
b = 7
id(a) == id(b) #true

c = 1000
d = 1000
id(c) == id(d) #false

del()函数用于删除变量

输入输出

输入

input()：读入一整行作为字符串

# <变量> = input(<提示性文字>)
>>> input("请输入：")
请输入：

输入integer

a = int(input())
# 其实int()是一个方法，完整表示是class int(x, base=10)
# x是字符串或者数字，base是进制，默认是十进制

输入list

>>> a = list(map(int, input.split()))
1 2 3 4
>>> a
[1,2,3,4]

>>> a = input.split()
1 2 3 4
>>> a
['1', '2', '3', '4']
>>> a = '3//11//2018'.split('/')
>>> a
['3', '', '11', '', '2018']

同时为多个变量赋值

用split()函数，用于把字符串按” “分开成一个list（每个元素都是字符串），也可以按照其他元素分开，给split()参数即可，例如3#4#5按#分开，用split('#')（即split()的参数默认为’ ‘）

在同行用空格分格读取三个整数的方法如下：

a, b, c = map(int, input().split())

另外一种trick

a, b, c = eval(input()) # 适用输入类似1，2，3情况（eval为直接去除字符串两边的“”，相当于三对三赋值）

输出

print()：以字符形式输出变量，可以输出各种类型变量的值

>>> print(3)
3
>>> print(3, 7)
3 7
>>> b, c = 3, 4
>>> print(b, c, 5)
3 4 5

更改end参数可以做到不换行输出等（end默认是\n）

print(3, end='')
print(4, end='')
#输出34

通过%来选择要输出的变量

# "<格式字符串>" %(<输出对象>, <输出对象> ...)
>>> print("Celsuis: %3d Fahr: %6.1f" %(celsuis, fahr))

格式化输出

%

整数：

>>> print('%o' %20) # %o 八进制
2 24
>>> print('%d' %20) # %d 十进制
4 20
>>> print('%x' %20) # %x 十六进制
6 14

浮点数：

# %f ——保留小数点后面六位有效数字
# 　　%.3f，保留3位小数位
# %e ——保留小数点后面六位有效数字，指数形式输出
# 　　%.3e，保留3位小数位，使用科学计数法
# %g ——在保证六位有效数字的前提下，使用小数方式，否则使用科学计数法
# 　　%.3g，保留3位有效数字，使用小数或科学计数法

>>> print('%f' % 1.11)  # 默认保留6位小数
1.110000
>>> print('%.1f' % 1.11)  # 取1位小数
1.1
>>> print('%e' % 1.11)  # 默认6位小数，用科学计数法
1.110000e+00
>>> print('%.3e' % 1.11)  # 取3位小数，用科学计数法
1.110e+00
>>> print('%g' % 1111.1111)  # 默认6位有效数字
1111.11
>>> print('%.7g' % 1111.1111)  # 取7位有效数字
1111.111
>>> print('%.2g' % 1111.1111)  # 取2位有效数字，自动转换为科学计数法
1.1e+03

字符串：

# %s
# %10s——右对齐，占位符10位
# %-10s——左对齐，占位符10位
# %.2s——截取2位字符串
# %10.2s——10位占位符，截取两位字符串

>>> print('%s' % 'hello world')  # 字符串输出
hello world
>>> print('%20s' % 'hello world')  # 右对齐，取20位，不够则补位
         hello world
>>> print('%-20s' % 'hello world')  # 左对齐，取20位，不够则补位
hello world         
>>> print('%.2s' % 'hello world')  # 取2位
he
>>> print('%10.2s' % 'hello world')  # 右对齐，取2位
        he
>>> print('%-10.2s' % 'hello world')  # 左对齐，取2位
he

format()函数

基本格式：str.format()

它的一般格式是：{<索引>:<填充字符><对齐方式><宽度.精度><格式>}

>>> '{0:*>10}'.format(10) #右对齐
'********10'
>>> '{0:*<10}'.format(10) #左对齐
'10********'
>>> '{0:*^10}'.format(10) #居中对齐
'****10****'
>>> '{0:.2f}'.format(1/3)
'0.33'
>>> '{0:b}'.format(10) #二进制
'1010'
>>> '{0:o}'.format(10) #八进制
'12'
>>> '{0:x}'.format(10) #16进制
'a'
>>> '{:,}'.format(12345678901) #千分位格式化
'12,345,678,901'

位置匹配：

>>> print(format(57.467645, ".3f"))
57.468

>>> print('{} {}'.format('hello','world'))  # 不带字段
hello world
>>> print('{0} {1}'.format('hello','world'))  # 带数字编号
hello world
>>> print('{0} {1} {0}'.format('hello','world'))  # 打乱顺序
hello world hello
>>> print('{1} {1} {0}'.format('hello','world'))
world world hello
>>> print('{a} {tom} {a}'.format(tom='hello',a='world'))  # 带关键字
world hello world

>>> print('{} and {}'.format('hello','world'))  # 默认左对齐
hello and world
>>> print('{:10s} and {:>10s}'.format('hello','world'))  # 取10位左对齐，取10位右对齐
hello      and      world
>>> print('{:^10s} and {:^10s}'.format('hello','world'))  # 取10位中间对齐
  hello    and   world   
>>> print('{} is {:.2f}'.format(1.123,1.123))  # 取2位小数
1.123 is 1.12
>>> print('{0} is {0:>10.2f}'.format(1.123))  # 取2位小数，右对齐，取10位
1.123 is       1.12

多种格式化：

• ‘b’ - 二进制。将数字以2为基数进行输出。
• ‘c’ - 字符。在打印之前将整数转换成对应的Unicode字符串。
• ‘d’ - 十进制整数。将数字以10为基数进行输出。
• ‘o’ - 八进制。将数字以8为基数进行输出。
• ‘x’ - 十六进制。将数字以16为基数进行输出，9以上的位数用小写字母。
• ‘e’ - 幂符号。用科学计数法打印数字。用’e’表示幂。
• ‘g’ - 一般格式。将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
• ‘n’ - 数字。当值为整数时和’d’相同，值为浮点数时和’g’相同。不同的是它会根据区域设置插入数字分隔符。
• ‘%’ - 百分数。将数值乘以100然后以fixed-point(‘f’)格式打印，值后面会有一个百分号。

>>> print('{0:b}'.format(3))
11
>>> print('{:c}'.format(20))

>>> print('{:d}'.format(20))
20
>>> print('{:o}'.format(20))
24
>>> print('{:x}'.format(20))
14
>>> print('{:e}'.format(20))
2.000000e+01
>>> print('{:g}'.format(20.1))
20.1
>>> print('{:f}'.format(20))
20.000000
>>> print('{:n}'.format(20))
20
>>> print('{:%}'.format(20))
2000.000000%

格式化输出的做法还挺复杂的，以后写码的时候再具体看吧 ：）

数据类型

python没有char没有double，分别用str和float覆盖了

type()可以用来获得数据类型

True是1，False是0（做算数的时候可以替换，但是type(True)是<class 'bool'）

一些内置的类型转换函数

bool() int() float() str() complex()就不多说了，会自动去掉前后空格、前置0等（但数据中间不能有空格）

>>> str(123)
'123'

chr()返回整数对应的Unicode字符

>>> chr(65)
'A'

ord() 返回Unicode字符对应的整数

进制转换：bin() oct() hex()（输出是str类型），int可用作转为十进制

>>> bin(3)
'0b11'
>>> int("35", 8) #把8进制的35转为十进制
29

list()

整数 int

• 二进制：0b或0B
• 八进制：0o或0O
• 十进制：0x或0X

64位机器可以表示的最大整数是9223372036854775807（但超过这个范围还是可以被表示）

浮点数 float

科学计数法：如1.23e9表示$1.23 \times10^9$，1.2e-5表示0.000012（e前后没有空格，e后面的数字是整数）

浮点数的表达有误差，例如

>>> 2.1-2.0
0.10000000000000009
>>> 3.2%2
1.2000000000000002

可以用sys.float_info查看浮点数信息

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

复数

<class 'complex'>

<real> + <image> j 可以是J或者j

实部虚部的数据类型都是float

用complex()函数创建，real方法取实部，imag方法取虚部

>>> a = complex(1,2)
>>> a
(1+2j)
>>> a.real
1.0
>>> a.imag
2.0

方法conjugate返回复数的共轭复数

$abs(a+bj) = \sqrt{a^2+b^2}$

序列

包含字符串（string）、列表（list）、元组（tuple）等

HERE

运算

python中没有++，但是可以用+=

sum()可以给list求和

>>> sum(range(1,11))
55
>>> sum([1,2,3])
6

%模，可以用作浮点数

>>> 3.4%2
1.4
# 3.4 - 1 * 2 = 1.4
# 但可能会有不精确问题，例如3.2%2=1.2000000000000002

/默认是浮点数除法，//默认是整数除法（向下取整，但如果有一个为float则是取整后的float）

>>> 5/3
1.6666666666666667
>>> 4/2
2.0
>>> 5//3
1
>>> 4//2
2
>>> 32.2//6
5.0
>>> -3//2
-2

math.sqrt()或**0.5可以开根号（float类）

乘方可以用pow()或者**

** 运算顺序从右往左，3**2**3先算2**3再算3**8

round(x)返回浮点数x的四舍五入的值，round(x,n) 返回浮点数x的四舍五入的小数点后的n位数值

其实是四舍六入五成双。1~4舍去， 6~9进位，当5时，如果5后面还有数字则进位，如果5后面没有数字的情况下，5前面的数字偶数则进位，5前面的数字是奇数则舍去。

n=0表示精确到个位，-1表示十位，负数以此类推

$ln$：math.log()

$log_{10}$：math.log10()

$log_2$：math.log2()

两个数字之间and，值为后面一个数字（除非有0）

math中的常用函数

比大小可以连着来

>>> 1<3<5 # 1<3 and 3<5
True
>>> 1<5>2 # 1<5 and 5>2
True

逻辑运算符，第一个条件符合就不用算第二个（第二个里面有error不会报）

逻辑运算符的优先级：not > and > or

>>> True or False and False
True

语句

通常一行一条，如一行中有多条，则用分号（;）分开，如果语句太长要跨行，可以续行符（\）跨行表示一个语句

赋值

不需要事先声明变量名及其类型，直接赋值即可创建各种类型的对象变量

在c中对变量的赋值，是直接把值给变量，而在python中，变量相当于一个标签，指向一个值。

所以在python中可以进行同步赋值交换变量的值，如下：

a,b = b,a # 交换变量的值（把a的值给b，把b的值给a）

单变量赋值

>>> x = 1
>>> y = 2
>>> k = x + y # k = 3

序列赋值

>>> x,y = 4,8 # x = 4, y = 8
>>> a,b = "34" # a = 3, b = 4
>>> a,b = "345" # error

不等长序列赋值

>>> i, *j = [1,2,3]
# i = 1, j = [2,3], i是int，j是list（注意j前面的*不能漏）

复合赋值

*=， +=， -= …

分支

if-else，注意冒号和缩进，语句块要对齐

条件表达式：类似if-else，三元

y = 10 if x > 20 else 30 # if x > 20, y = 10; else y = 30

循环

for <variable> in <container>
for <variable> in <list>
for <variable> in range(<value>)

range(start, stop, step)
# 左闭右开，start默认为0，step默认为1，可以为负
# 如果省略了start，必须也省略step

while-else：通常和break配合使用，else后面跟能够在循环正常结束时可以执行的操作（如果break则不执行else）

while i < a:
  ...
else:
  ...