变量和简单数据类型

此文章只用来记录python的特别之处及值得注意的点。

基本概念及要点

1. 编译器与解释器
   编译器：一次性翻译全部，翻译完成之后再执行，后续在执行时，无需再翻译，速度快，无法跨系统移植。
   解释器：翻译一行执行一行，边翻译边执行，速度慢，但可以跨系统移植。

2. 编程约定
   标识符：
   变量，关键字，函数，类等的组成，上述名称只能由数字，字母，下划线组成，且在命名时，数字不能放在名称首字符。内置函数组成字母不能大写。
   python语言大小写敏感。
   以下划线开头的标识符通常具有特殊的意义。以单下划线开头代表类中不能直接访问的成员，需通过类提供的接口进行访问。以双下划线开头代表类的私有成员。以双下划线开头和结尾的代表Python中特殊方法的专用标识，__init()__代表类的构造函数。

3. 基本的代码格式
   多行语句。一般一行一语句，当语句过长时使用\将一行语句分成多行显示，若语句中包含（）,[],{}就不需要使用多行连接符。
   多行缩进格式。

4. Python保留关键字

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

5.注释使用 “#”

变量和简单的数据类型

变量

1.在python语言中，变量在指定的同时，必须强制赋初值，否则解释器报错。
2.python允许同时为多个变量赋初始值
若这些变量的值相等，则这些变量在内存中指向同一个地址，获得同一个值。即均为引用类型

>>> print(one,two,three)
10 10 10
>>> one,two,three=10
>>> x,y,z=10,10,10
>>> print(x,y,z)
10 10 10

3.所有的变量值都是分类型的，python语言变量值的类型在赋值后才被隐性确定。
4.python的基本变量类型：字符串String,数字Numeric,列表List,元组Tuple,字典Dictionary。

字符串

1.可以用成对的单引号，双引号，三引号表示。但是三引号 '" "'有其独特的优势，三引号允许一个字符串跨多行，字符串中可以包括换行符，制表符以及其它特殊字符。
2.反斜杠\开头代表字符转移符号。
3.字符串的基本操作：读取，合并，修改，删除。
4.读取：
单下标读取：索引读取，每个字符都可看作一个字符数组。
切片读取：类似于matlabz中数组的读取。“左下标：右下标”，左下标可以取到，右下标取不到，相当于左闭右开。
带冒号省略下标方式切片：例如[:右下标]，[左下标:],[:]省略代表全部读取。
带步长的切片读取：步长相当于间隔，即有间隔读取。[左下标:右下标:步长]
负数下标读取：有负数下标从右到左读取对应的字符串值。

>>> name="Tom is a cat!"
>>> name[1]
'o'
>>> name[1:4]
'om '
>>> name[:3]
'Tom'
>>> name[:]   #读取整个字符串
'Tom is a cat!'
>>> name[::2]  #从头到尾，间隔为2，挑选式读取字符串
'Tmi  a!'
>>> name[-1]  #符号代表反向，从右往左，读取第一个字符
'!'
>>> name[-4:-1]  #依旧符合左闭右开原则，从1开始
'cat'

5.字符串的合并：采用加号+进行合并操作。
6.修改：通过读取子字符串加合并的方式实现，不能直接对字符串做修改。

>>> name="Three cool cat!"
>>> new_name=name[:11]+"dog!"
>>> print(name)
Three cool cat!
>>> print(new_name)
Three cool dog!
>>> name[6]
'c'
>>> name[6]="a"
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    name[6]="a"
TypeError: 'str' object does not support item assignment

7.删除：利用del方法。
8.获取字符串的长度：len()函数
len(x)可以获取x的长度，x可以是字符串，列标，元组，字典。
在python3中，一个汉字一个长度。
9.原始字符串控制符号r/R：转义字符不起作用

>>> print('C:\back\name')
C:ack
ame
>>> #\b表示退格符，退一格，\n表示换行符
>>> print(r'C:\back\name')
C:\back\name

3.重复输出字符串（*）：字符串*n,输出n遍。
4.格式字符串%或者format()函数。

>>> age=10
>>> print("Ton's age is %d"%(age))
Ton's age is 10

%.2f保留小数点后2位。
5.由此可以看出，python中print()的用法与c类似。

数字和运算符

1.数字分为整数，浮点数，复数，布尔。
2.**幂运算，取整除：//，/的结果一律为浮点数。

>>> print(5**3)
125

3.在python语言里，整数的长度不受限制，仅受可用内存的限制。
4.优先级：幂>乘，除，取余，取整>加，减。
5.由于计算机存储浮点数的位数有限，所以超过指定长度后，末尾将做近似处理。所以浮点数不一定是精确值。
6.复数：在python中$j$为虚数单位。
7.布尔类型True或者False。
8.逻辑运算符：and 与，or 或，not 非。
9.二进制：二进制数前面标有0b。十进制转二进制数表示使用函数bin()。
二进制运算符：&按位与，|按位或，^按位异或（相同为0，不同为1），~按位反，<<左移位运算符（全部左移x位，超出丢弃，低位补0），>>右移动运算符（全部右移x位，高位补0，低位丢弃）。左移运算符与右移运算符

---------------------------------------------------------------------------------------------------------

关于位运算的补充

1. 基本概念：
   二进制有三种表示方式：原码，反码和补码，计算机内部使用补码来表示。

• 原码：就是二进制的表示（有符号整数有一位符号位）
• 反码：正数的反码就是原码，负数的反码是符号位不变，其余位按位取反（对应正数按位取反）
• 补码：正数的补码就是原码，负数的补码是反码+1。
• 符号位：最高位为符号位，0表示正数，1表示负数。在位运算中符号位也参与运算。
  对于正数：原码=反码=补码；
  对于负数：补码=原码的反码+1；（取反前减1和在取反后加1的效果是一样的）原码=补码的反码+1；

2. 按位取反的原理
   例：9按位取反为-10。
   9的原码：01001，二进制在计算机中是以补码的形式存在的，所以9的补码：01001。对01001按位取反为10110 （符号位也参与运算）。所以所求~9的补码是10110，是个负数，再利用负数的性质：原码=补码取反+1。所以 ~9的原码是11010=-10。所以 ~9=-10
3. 移位运算符
   应用：利用移位运算符快速计算2的倍数的问题。
   1<<n - >2^n
   左移n位相当于乘以pow（2，n）。
   右移n位相当于用pow（2，n）做地板除。

print(bin(4))
print(bin(4>>2),4>>2)#4/pow(2,2)
print(bin(4<<2),4<<2)#4*pow(2,2)
0b100
0b1 1
0b10000 16

4. 按位取异或^
   应用：快速交换两个数

a=3
b=5
a^=b
b^=a
a^=b
print(a,b)#5，3

5. 按位取交&
   应用：通过 a & (-a) 快速获取a的最后为 1 位置的整数。

 00 00 01 01 -> 5
&
11 11 10 11 -> -5
---
00 00 00 01 -> 1

00 00 11 10 -> 14
&
11 11 00 10 -> -14
---
00 00 00 10 -> 2

6. 通过位运算实现整数集合
   一个数的二进制表示可以看作是一个集合（0 表示不在集合中，1 表示在集合中）。
   比如集合 {1, 3, 4, 8}，可以表示成 01 00 01 10 10 而对应的位运算也就可以看作是对集合进行的操作。
   元素与集合的操作：

a | (1<<i) -> 把 i 插入到集合中
a & ~(1<<i) -> 把 i 从集合中删除
a & (1<<i) -> 判断 i 是否属于该集合（零不属于，非零属于）

集合之间的操作:

a 补 -> ~a
a 交 b -> a & b
a 并 b -> a | b
a 差 b -> a & (~b)

注意：整数在内存中是以补码的形式存在的，输出自然也是按照补码输出。
C#语言输出负数:

class Program
{
    static void Main(string[] args)
    {
        string s1 = Convert.ToString(-3, 2);
        Console.WriteLine(s1); 
        // 11111111111111111111111111111101
        
        string s2 = Convert.ToString(-3, 16);
        Console.WriteLine(s2); 
        // fffffffd
    }
}

python的bin()输出：

print(bin(3))  # 0b11
print(bin(-3))  # -0b11

print(bin(-3 & 0xffffffff))  
# 0b11111111111111111111111111111101

print(bin(0xfffffffd))       
# 0b11111111111111111111111111111101

print(0xfffffffd)  # 4294967293

• Python中bin一个负数（十进制表示），输出的是它的原码的二进制表示加上个负号。
• Python中的整型是补码形式存储的。
• Python中整型是不限制长度的不会超范围溢出。

所以为了获得负数（十进制表示）的补码，需要手动将其和十六进制数0xffffffff进行按位与操作，再交给bin()进行输出，得到的才是负数的补码表示。
---------------------------------------------------------------------------------------------------------

10.比较运算符：==，>=,<=,!=,<,>。仅仅是值的比较，整数。
11.优先级：算术运算符（一元运算符大于二元运算符），移位运算符，位运算符，比较运算符，逻辑运算符。
12.python中没有三目运算符。
但是python中有三元运算符（非常类似于三目运算符）

x,y=0,4
if x<y:
    min=x
else:
    min=y
print(min)
#等价于
x,y=0,4
min = x if x < y else y
print(min)
0

其他运算符

操作符	名称	示例
in	存在	'A' in ['A', 'B', 'C']
not in	不存在	'h' not in ['A', 'B', 'C']
is	是	"hello" is "hello"
is not	不是	"hello" is not "hello"

a = "hello"
b = "hello"
print(a is b, a == b)  # True True
print(a is not b, a != b)  # False False
a = ["hello"]
b = ["hello"]
print(a is b, a == b)  # False True
print(a is not b, a != b)  # True False

• is, is not 对比的是两个变量的内存地址
• ==, != 对比的是两个变量的值
• 比较的两个变量，指向的都是地址不可变的类型（str等），那么is，is not 和 ==，！= 是完全等价的。
• 对比的两个变量，指向的是地址可变的类型（list，dict，tuple等），则两者是有区别的。

数据类型与转换

1. 使用内置函数进行数据类型的转换：
   int(x),转换成整数，不支持复数转整数。
   float(x):不支持复数转浮点数。
   complex(x,y):x为实部，y为虚部。
   str(x):转字符串。
   bin(x):转二进制。
   oct(x):转八进制。
   hex(x):转十六进制。
   chr(x):把十进制数转成ASCII字符。
   ord(x):把ASCII字符转十进制数。
2. 数据类型
   对于python来说，万物皆对象。只要是对象，就会有相应的属性（attributes）和方法(methods)。
   dir()获取对象的属性和方法。

• 整型 int
  例：bit_length()-----找到这个整数的二进制，在返回这个二进制的长度。

a=4
print(bin(a))
print(a.bit_length())
0b100
3

• 浮点型
  当我们要保留小数点后n位时，可以用decimal包中的Decinal对象和getcontext()方法来实现。

import decimal as de
a=de.getcontext()
print(a)
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, 
capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
#输出了getcontext的性质

getcontext默认精度值为为28位。可以通过方法getcontext().prec来调整精度。
使用Decimal，int类型可以直接用来构造Decimal，但是float类型的变量要先转换为字符串。在进行运算之后结果会使用getcontext().prec来确定精度，例如prec为5的时候，100.1234567890+0会等于100.12

import decimal as de
#或者：import decimal 
#from decimal import Demical具体见import的具体应用
a=de.getcontext()
print(a)
print(de.Decimal(1)/de.Decimal(3))#0.3333333333333333333333333333
de.getcontext().prec=4
print(de.Decimal(4.509))#4.5090000000000003410605131648480892181396484375
print(de.Decimal('4.5'))#4.5
b=de.Decimal(1)/de.Decimal(3)
print(b)#0.3333

decimal用于浮点数的四舍五入，要先把浮点数转换为字符串。

from decimal import *
Decimal('50.5679').quantize(Decimal('0.00'))
# 结果为Decimal('50.57')，结果四舍五入保留了两位小数

转化为字符串显示

from decimal import *
str(Decimal('3.40').quantize(Decimal('0.0')))
# 结果为'3.4'，字符串类型