数值数据是表示数量大小的数据，有多种表示方法。日常生活中一般采用十进制数进行计数和计算，但十进制数难以在计算机内直接存储与运算。在计算机系统中，通常将十进制数作为人机交互的媒介，而数据则以二进制数的形式存储和运算。
计算机采用二进制的主要原因有以下几点：
（1）易于物理实现
二进制在技术上最容易实现。这是因为具有两种稳定状态的物理器件很多，如门电路的导通与截止、电压的高与低等，而它们恰好可以对应表示“1”和“0”这两个数码。假如采用十进制，那么就要制造具有10种稳定状态的物理电路，而这是非常困难的。
 
（2）运算规则简单
数学推导已经证明，对R进制数进行算术求和或求积运算，其运算规则各有R(R+1)/2种。如采用十进制，则R=10，就有55种求和或求积的运算规则；而采用二进制，则R=2，仅有3种求和或求积的运算规则，
以加法为例：0+0=0，0+1=1 (1+0=1)，1+1=10，因而可以大大简化运算器等物理器件的设计。
（3）机器可靠性高
由于电压的高和低、电流的有和无等都是一种质的变化，两种物理状态稳定、分明，因此，二进制码传输的抗干扰能力强，鉴别信息的可靠性高。
（4）逻辑判断方便
采用二进制后，仅有的两个符号“1”和“0”正好可以与逻辑命题的两个值“真”和“假”相对应，能够方便地使用逻辑代数这一有力工具来分析和设计计算机的逻辑电路。
但是，用二进制表示一个数，其所使用的位数要比用十进制表示长得多，书写和阅读都不方便，也不容易理解。为了书写和阅读的方便，人们通常使用十六进制来弥补二进制的这一不足。
1. 进位计数制
在人类的生产和生活中，经常要遇到数的表示问题，人们通常采用从低位向高位进位的方式来进行计数，这种表示数据的方法称为进位计数制。讨论进位计数制要涉及到两个基本概念：基数（Radix）和权（Weight）。
1）十进制
在进位计数制中，每个数位所用到的数码符号的个数叫做基数。十进制是人们最熟悉的一种进位计数制，每个数位允许选用0~9共10个不同数码中的某一个，因此十进制的基数为10。每个数位计满10就向高位进位，即“逢10进1”。
在一个数中，数码在不同的数位上所表示的数值是不同的。每个数码所表示的数值就等于该数码本身乘以一个与它所在数位有关的常数，这个常数叫做权。例如：十进制数6543.21，数码“6”所在数位的权为1000，这一位所代表的数值即为6×103=6000，“5”所在数位的权为100，这一位所代表的数值即为5×102=500，……。
2）二进制
计算机中信息的存储、处理和传送采用的都是二进制，不论是指令还是数据，或是多媒体信息（声音、图形、图像等），都必须采用二进制编码形式才能存入计算机中。
 
二进制是一种最简单的进位计数制，它只有两个不同的数码：“0”和“1”，即基数为2，逢2进1。任意数位的权是2i。
3）十六进制
十六进制数的基数为16，逢16进1，每个数位可取0,1,…,9,A,B,…,F共16个不同的数码和符号中的任意一个，其中A~F分别表示十进制数值10~15。
既然有不同的进位计数制，那么在给出一个数的同时，就必须指明它是哪种进制的数，例如：(1010)2、(1010)10、(1010)16 所代表的数值完全不同，如果不用下标加以标注，就会产生歧义。除了用下标表示之外，还可以用后缀字母来表示不同的数制，后缀B表示该数是二进制（Binary）数，后缀H表示该数是十六进制（Hexadecimal）数，而后缀D表示该数是十进制（Decimal）数。十进制数在书写时可以省略后缀D，其他进制数在书写时一般不能省略后缀。例如：有3个数分别为375D、101B和AFEH，从后缀字母就可以知道它们分别是十进制数、二进制数和十六进制数。
2. 各种进制数之间的转换
1）二进制数转换为十六进制数
将一个二进制数转换成十六进制数的方法是将二进制数的整数部分和小数部分分别进行转换，即以小数点为界，整数部分从小数点开始往左数，每4位分成一组，当最左边的数不足4位时，可根据需要在数的最左边添加若干个“0”以补足4位；对于小数部分，从小数点开始往右数，每4位分成一组，当最右边的数不足4位时，可根据需要在数的最右边添加若干个“0”以补足4位，最终使二进制数的总的位数是4的倍数，然后用相应的十六进制数取而代之。
例如：
111011.1010011011B = 0011 1011.1010 0110 1100B = 3B.A6CH
2）十六进制数转换为二进制数
要将十六进制数转换成二进制数，只要将1位十六进制数写成4位二进制数，然后将整数部分最左边的“0”和小数部分最右边的“0”去掉即可。
例如：
3B.328H = 0011 1011.0011 0010 1000B = 111011.001100101B
3）二进制数转换为十进制数
要将一个二进制数转换成十进制数，只要把二进制数的各位数码与它们的权相乘，再把乘积相加，就得到对应的十进制数，这种方法称为按权展开相加法。
例如：
100011.1011B = 1×25 + 1×21 + 1×20 + 1×2-1 + 1×2-3 + 1×2-4= 35.6875D
4）十进制数转换为二进制数
要将一个十进制数转换成二进制数，通常采用的方法是基数乘除法。这种转换方法是对十进制数的整数部分和小数部分分别进行处理，整数部分用除基取余法，小数部分用乘基取整法，最后将它们拼接起来即可。
（1）十进制整数转换为二进制整数（除基取余法）
十进制整数转换为二进制整数的规则是：除以基数（2）取余数，先得到的余数为低位，后得到的余数为高位。
具体的做法是：用2连续去除十进制整数，直到商等于0为止，然后按逆序排列每次的余数（先取得的余数为低位），便得到与该十进制数相对应的二进制数各位的数值。
例如，将175D转换成二进制数：

所以，175D=10101111B
（2）十进制小数转换为二进制小数（乘基取整法）
十进制小数转换为二进制小数的规则是：乘以基数（2）取整数，先得到的整数为高位，后得到的整数为低位。
具体的做法是：用2连续去乘十进制数的小数部分，直至乘积的小数部分等于0为止，然后按顺序排列每次乘积的整数部分（先取得的整数为高位），便得到与该十进制数相对应的二进制数各位的数值。
例如，将0.3125D转换成二进制数：
0.3125×2 = 0.625       …　整数0       （高位）
0.625×2  = 1.25        …　整数1
0.25×2   = 0.5         …　整数0
0.5×2    = 1.0         …　整数1       （低位）
所以，0.3125D = 0.0101B
若要将十进制数175.3125转换成二进制数，应对整数部分和小数部分分别进行转换，然后再进行整合：
175.3125D=10101111.0101B
需要注意的是，十进制小数常常不能准确地换算为等值的二进制小数，存在有一定的换算误差。
例如，将0.5627D转换成二进制数：
0.5627×2 = 1.1254
0.1254×2 = 0.2508
0.2508×2 = 0.5016
0.5016×2 = 1.0032
0.0032×2 = 0.0064
0.0064×2 = 0.0128
……
由于小数位始终达不到0，因此这个过程会不断进行下去。通常的做法是：根据精度要求，截取一定的数位，其误差值小于截取的最低一位数的权。
当要求二进制数取m位小数时，一般可求m+1位，然后对最低位作“0舍1入”处理。
例如：
0.5627D = 0.100100…B
若取精度为5位，则由于小数点后第6位为“0”，被舍去，所以：
0.5627D = 0.10010B




转载自：http://share.onlinesjtu.com/mod/tab/view.php?id=172

理解二进制和十六进制的最佳方法是先透彻的领悟十进制计数系统。十进制（Decimal）系统是基于10的计数系统（词根Deci-表示10）。“基于10”指的是由10个数位（Digit）0到9来表示数。 
使用“位置（Place Value）”，可以用不多的几个数位（如10个十进制数位）来表示很大的数。所有计数系统的位置从最右边开始，是基数的0次幂。从右往左，基数的幂依次增加1： 
X4X3X2X1X0
基数是10时，前5个位值是： 104103102101100
对任何基数，前两个位值是最容易计算的。任何数的0次幂是1，所以100=1。任何数的1次幂就是它本身，所以101 = 10。第三个位值也是容易计算的，只要简单地用第二个位值乘以基数就可以。事实上，每一个位值都可以用它前面一个位值乘以基数计算出来。所以上面5个位值是： 
100= 1 = 1
101= 1×10 = 10
102= 10×10 = 100
103= 100×10 = 1000
104= 1000×10 = 10000
根据位值来读一个数，比如57 258，指的是有5个10 000，7个1 000，2个100，5个10，以及8个1。
就是说： 5×10 000 = 50 000 7×1 000 = 7 000 2×100 = 200 5×10 = 50 8×1 = 8 将这些结果相加，结果：50 000 + 7000 + 200 + 50 + 8=57 258。
 我们对十进制非常熟悉。所以，我们很少会去考虑将一个数分解成位值。但是，这种方法对于阐明其他进制的数是非常至关重要的。          
二进制数   计算机从最底层来看，只不过是电子开关的集合而已。而数字和字符是由这些开关的状态来表示的。由于一个开关仅有两种状态——“开”或者“关”，所以它使用二进制（Binary），或者说基数为2的计数系统（词根bi表示2）。一个基数为2的系统仅仅有两个数位：0和1。计算机通常将这两个数位集合成8个位值，即一个字节（Byte）或八位组字节（Octet）。
这8个位值是： 2726252423222120 位值这样计算：
 20 = 1 
21 = 1×2 = 2 
22 = 2×2 = 4 
23 = 4×2 = 8 
24 = 8×2 = 16 
25 = 16×2 = 32 
26 = 32×2 = 64 
27 = 64×2 = 128 所以一个二进制八位组的位值： 128 、64 、32 、16 、8 、4 、2 、1
 因此，二进制八位组10010111可以这样理解： 
1×128 = 128 
0×64 = 0 
0×32 = 0 1×16 = 16 
0×8 = 0 
1×4 = 4 
1×2 = 2 
1×1 = 1 
或者：128 + 16 + 4 + 2 + 1 = 151 对于二进制数，因为每一个位值要么就是该值本身，要么就没有，所以比较简单。
另外一个例子：11101001 = 128 + 64 + 32 + 8 + 1 = 233。就是说，将二进制转换为十进制仅仅是一个将位值相加的过程，将十进制转换为二进制仅仅是将位值相减的过程。
例如，要将十进制数178转为二进制，首先把178减去最高的位值：
 1、178大于128，所以我们就知道在该位值上有一个1： 178 – 128 = 50。
 2、50比64小，该位值上有一个0。
 3、50比32大，所以该位值上有一个1：    50 – 32 = 18。
 4、18比16大，该位值上有一个1：    18 – 16 = 2。
5、2比8小，该位值上有一个0。
 6、2比4小，该位值上有一个0。
 7、2等于2，该位值上有一个1：    2 – 2 = 0。
 8、0小于1，该位值上有一个0。
 把这些步骤的结果综合起来，用二进制表示178是：10110010。
 另外一个例子可能会有帮助。给出110：
 1、110比128小，所以在该位值上有一个0。
 2、110比64大，所以在该位值上有一个1：    110 – 64 = 46。 
3、46比32大，所以在该位值上有一个1：    46 – 32 = 14。
 4、14比16小，所以在该位值上有一个0。
 5、14比8大，所以在该位值上有一个1：    14 – 8 = 6。 
6、6比4大，所以在该位值上有一个1：    6 – 4 = 2。
 7、第2个位值上有一个1：    2 – 2 = 0。
 8、0比1小，所以在该位值上有一个0。 所以，110用二进制表示就是：01101110。 
 
十六进制数   写一个二进制八位组并不有趣。对于经常要使用这些数字的人来说，受欢迎的是更简洁的表示法。一个可能的表示法是为每一个可能的八位组分配一个单独的字符。但是，8位有28 = 256种不同的组合，所以，用单独的字符表示所有八位组需要256个数位，或者说一个基数为256的计数系统。 将一个八位组看作是两个各4位的组合或许会更简单一些。例如，11010011可以看作是1101和0011。对4个位来说，有24 = 16种不同的组合，所以有基数16，或者说十六进制（Hexadecimal）计数系统，一个八位组可以用两位来表示（词根hex的意思是“six”，deci的意思是“ten”）。
 十六进制 十进制 二进制 
0 0 0000
 1 1 0001
 2 2 0010
 3 3 0011
 4 4 0100 
5 5 0101
6 6 0110
 7 7 0111
 8 8 1000
 9 9 1001 
A 10 1010 
B 11 1011 
C 12 1100 
D 13 1101 
E 14 1110 
F 15 1111   
因为十六进制和十进制的前10个数字是一样的，所以我们有意在一个十六进制数前面加0x，或者在后面加一个h，以便和十进制数区分开。例如，十六进制数9应该写成0x9或者9h。 刚才学过二进制的表示法，很容易写出一个4位二进制数的十进制表达形式。同样也很容易将一个十进制数转为十六进制。
于是，我们可以很容易地通过3个步骤将一个二进制八位组转为十六进制：
 1、将八位组分成2个4位的二进制数。 
2、将每个4位二进制数转为十进制。
 3、把每个十进制数用十六进制来表示。
 例如：把11010011转为十六进制：
 1、11010011变成1101和0011。
2、1101 = 8 + 4 + 1 = 13，0011 = 2 + 1 = 3。
 3、13 = 0xD，3 = 0x3。 所以，11010011用十六进制表示就是0xD3。 
把十六进制转为二进制是上述3步的简单逆序。例如，把0x7B转为二进制：
 1、0x7 = 7，0xB = 11。 
2、7 = 0111，11 = 1011。
 3、把2个4位二进制数写在一起就是0x7B = 01111011，十进制为123。
 

网页中的预定义色，使用英文单词进行颜色的表示；比如red，blue等
三位的十六进制；比如#F00(每个颜色由一个十六进制来表示)
六位的十六进制；比如#FF0000(每个颜色由两个十六进制来表示)
RGB三原色：RGB(255,0,0)这给定的三个参数表示红，绿，蓝的颜色值，由0到225的十进制表示
RGB，RGB(100%,0%,0%)，使用百分号表示

注：以上五种表达方式都是属于RGB色系(红，绿，蓝)

RGBA：和RGB一样，只是多了一个透明度，比如RGB(255,0,0,0.5)。第四个值取值范围为0-1，0是完全透明，1是完全不透明
HSL(学习后期调色的使用比较多)：色相、饱和度、亮度。比如HSL(360,100%,50%)。

色相：是色彩的基本属性，就是平常所说的颜色名称，比如红色等

饱和度：是指色彩的纯度，越高色彩越纯，低则逐渐变灰，取0-100%的数值

亮度：就是色彩的明亮程度，色彩的明度越高，色彩越亮；色彩的明度越暗，色彩越暗，取0-100%。

(当要页面要使用一个色系时，可使用HSL)
HSLA：比HSL多了个透明度。

变量类型

变量是计算机存储数据的内存空间，由于计算机可以处理不同的数据，不同的数据就要定义不同的数据类型。python的数据类型很多，还可以自定义数据类型，常用的一般数据类型有以下几种：
整型：

在python2版本中有long和int之分，但到了python3中就只有int了。

除此之外，整型还有进制的概念：二进制：0b10表示十进制2，八进制：0o10表示十进制8，十进制：10，十六进制：0x10表示十进制16

浮点型：

即float，也就是小数，称之为浮点型是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的。

字符串

以"或’括起来的字符，比如：“hello, world”。

在表示多行字符串时，可以使用三个单引号(’’’)/双引号(""")括起来

布尔型

表示的是真或假，通常使用True或False表示。

一些表达式的结果也可以表示真假，如：1 != 2

空的数据类型（""、[]、{}）和None和0表示False，反之为True

复数

如3+5j，跟数学上的复数表示一样，唯一不同的是虚部的i换成了j，了解即可。

函数

基本概念

计算机的函数实质上就是一段有特定功能的代码，使用函数可以有效的减少代码的耦合度，同时提高代码的可读性和易维护性。
函数的写法

计算机的函数和数学的函数有一定的相似性：
有参数，相当于数学函数的自变量

有返回值，相当于数学函数的因变量

python 的函数使用def关键词定义，需要写上函数名称，而参数值和返回值需要根据需求考虑是否填写。

如：
def foo(num):
	return num + 1

参数

前面说过，参数就相当于数学函数的自变量，主要是一些在函数体中用到的值，python的参数可以指定默认的参数。
def pow(num, count=2):
	"""计算多少次方"""
	return num ** count
	
if __name__ == "__main__":
	print(pow(2))		# 4
	print(pow(2, 3))	# 8

上面的函数的count参数即指定了默认参数count=2，对于某些对于参数不确定的函数还可以使用不定长参数，其方式一般为*args或**kwargs，这两个参数接收的值的类型分别为list和dict。
def foo(*args, **kwargs):
    for a in args:
        print(a)
    for k, v in kwargs.items():
        print(k, v)


if __name__ == "__main__":
    foo(1, 2, 3, **{"a": 4, "b": 5, "c": 6}, d=7)

需要注意的是：在传入参数时，可以根据函数参数的位置传参，也可以根据根据参数的关键字传参。二者可以结合使用，但位置参数一定要在关键字参数之前。

比如对于def foo(a, b, c)来说，既可以foo(1, 2, 3)也可以foo(b=2, a=1, c=3)还可以foo(1, c=3, b=2)但不能foo(c=3, 1, 2)。
返回值

使用返回值需要用到一个关键词return，一个函数的返回值可以是一个或多个值，也可以是一个函数。
导入模块

由于python没有函数重载的概念，所以假如定义了相同函数名的函数时，前一个函数会被后一个函数所覆盖：
def foo():
	print("foo1")

def foo():
	print("foo2")

在日常的开发过程中，假如是一个人开发的话可以为不同的函数取不同的名字，但假如是多人开发的话就有可能使用相同的函数名。多人开发时通常使用模块（module）开发，在使用时可以使用import关键字导入某个指定的模块。

m1.py:
def foo():
	print("foo1")
	
m2.py:

def foo():
	print("foo2")

在使用时：
import m1

import m2
使用
m1.foo()

m2.foo()

需要注意的是：导入模块时会将模块的内容执行一遍，假如不想这样的话，可以使用一个判断语句，使代码主动执行时运行，而不是导入时也运行。
def foo():
	print("foo")
	
if __name__ == "___main__":
	foo()

name__是Python中一个隐含的变量它代表了模块的名字，只有被Python解释器直接执行的模块的名字才是__main。
作用域

作用域就相当于一个变量可以使用的范围，该作用域的变量只能本作用域和子作用域可用。有了作用域这个概念就有了全局变量和局部变量这两者变量，全局变量即声明在全局作用域中的变量，而局部变量则不是声明在全局的变量，一般来说是一些函数内部声明的变量。
n = 2	# 全局变量

def foo():
	m = 3	# 局部变量

根据python的规则，变量会优先找本作用域的，假如找不到会依次往外找，直至找到，当找不到时就会报错。
age = 19
def main():
	print(age)
	
main()

但假如要修改外部作用域的变量时，必须使用global和nonlocal这两个关键字声明一下，否则报错。因为python会认为修改的这个动作其实是声明，也就是说python没有朝外找变量，假如使用变量在声明变量之前的话，就会报错：UnboundLocalError: local variable ‘xxx’ referenced before assignment。
# 这是错误的示范
age = 18

def main():
    print(age)
    age = 20


main()
print(age)
正确的方法：

global
age = 18

def main():
    global age
    print(age)
    age = 20

main()
print(age)

如果我们希望函数内部的函数能够修改嵌套作用域中的变量，可以使用nonlocal关键字来指示变量来自于嵌套作用域。

2. nonlocal
def test1():
    count = 0
    def test2():
        nonlocal count
        count += 1
        return count
    return test2()
 
print(test1())

练习

实现计算求最大公约数和最小公倍数的函数。
几个整数中公有的约数，叫做这几个数的公约数；其中最大的一个，叫做这几个数的最大公约数。例如：12、16的公约数有1、2、4，其中最大的一个是4，4是12与16的最大公约数。
实现判断一个数是不是素数的函数
# 第一题 求最大公约数和最小公倍数
def gcd(x, y):
    """最大公约数"""
    (x, y) = (y, x) if x > y else (x, y)
    for i in range(x, 0, -1):
        if x % i == 0 and y % i == 0:
            return i


def lcm(x, y):
    """最小公倍数"""
    return x * y // gcd(x, y)


# 第二题
def is_prime(num):
    """判断一个数是不是素数"""
    for factor in range(2, int(num ** 0.5) + 1):
        if num % factor == 0:
            return False
    return True if num != 1 else False

常用数据结构

字符串 str

字符串实质上就是由字符组成的有序序列。前面说过字符串是以引号括起来的，引号里面的内容可以使用\进行转义，使一般的字符特殊化，如："\n"表示换行，"\"表示反斜杠\，除此之外转义符还可以跟八进制（\141）、十六进制（\x61）和Unicode编码。

一些常用的转义符




字符
含义




|	在行尾时是续行符



\
反斜杠符号


’
单引号


"
双引号


\a
响铃


\b
退格


\e
转义


\000
空


\n
换行


\v
纵向制表符


\t
横向制表符


\r
回车


\f
换页


除了转义以外，字符串还有很多使用方法。
切片

s = “hello, world”
print(s[1:4])

如上所述，切片实质上就是拿中括号写成[开头:结尾:步长]的形式（步长可以省略，且默认为一），把需要截取的一部分内容取出来，不过需要注意的是：切片里面的数不能超过要切片的范围，python的索引以0开始。假如要取开头([:n])或结尾（[n:]）的话，可以空着。
其他方法

python的字符串还有很多的其他方法，这些方法本质上就是一些函数，使用时以"".xxx()的形式调用。

s = “hello world”
# 大写
print(s.upper())    # HELLO WORLD

# 首字母大写
print(s.title())    # Hello World

# 小写
print(s.lower())    # hello world

# 替换
print(s.replace("world", "world!"))  # hello world!

# 分割
print(s.split(" "))  # ['hello', 'world']

# join
print(" ".join(["hello", "world"]))  # hello world

# 两边去空
print("  hello world  ".strip())    # hello world

# 查找
# 找的是第一个的位置，用rfind可以找最后一个
print(s.find("l"))      # 2
# print(s.index("t")) # 找不着时会报错

# 判断开头、结尾
print(s.startswith("hello"))    # True
print(s.endswith("ld"))         # True
列表 list
列表也是python的一种常用的数据结构，上面例子中split方法的结果就是一个列表。列表由一个个元素组成，各个元素的类型可以各不相同，与字符一样，列表可以切片、也有一些特定的方法，不一样的是，列表可以直接通过索引对元素进行修改，而字符串则不可以。

fruits_list = ["apple", "pear", "peach", "banana"]

print(fruits_list[1:])  # ['pear', 'peach', 'banana']

# 修改值
fruits_list[2] = "orange"   # ['apple', 'pear', 'orange', 'banana']

# 追加
fruits_list.append("pear")  # ['apple', 'pear', 'orange', 'banana', 'pear']

# 插入
# 第一个参数是位置，第二个参数是要插入的元素

fruits_list.insert(0, "cherry")
# ['cherry', 'apple', 'pear', 'orange', 'banana', 'pear']


# 迭代添加一个列表

fruits_list.extend(["watermelon", "lemon"])
# ['cherry', 'apple', 'pear', 'orange', 'banana', 'pear', 'watermelon', 'lemon']


# 删除
# 按索引位置删除
fruits_list.pop(0)
# ['apple', 'pear', 'orange', 'banana', 'pear', 'watermelon', 'lemon']


# 删列表中的第一个指定值

fruits_list.remove("pear")
# ['apple', 'orange', 'banana', 'pear', 'watermelon', 'lemon']


# 排序
# 可以跟匿名函数lambda：fruits_list.sort(key=lambda x: len(x))

fruits_list.sort()
# ['apple', 'banana', 'lemon', 'orange', 'pear', 'watermelon']


# 查找
# 第一个指定值的位置
print(fruits_list.index("pear"))    # 4

# 清空
fruits_list.clear()  # []

元组 tuple

元组是一种类似于列表的数据结构，它以小括号()括起来为一个元组，元组的元素同样可以是任意的。但是需要注意的是，元组的元素并不能被改变，这一种特性这某些场合中适用，如某些重要的数据、不允许改变的类属性(slots)和函数的多返回值。由于元组不能被修改，所以我们只需要关注其定义和使用即可。
# 定义元组

fruits_tuple = ("apple", "pear", "peach", "banana")
# 也可以使用tuple从其他可迭代数据转换过来
fruits_tuple = tuple(["apple", "pear", "banana", "peach", "banana"])
print(fruits_tuple)

# 遍历
for f in fruits_tuple:
    print(f)


# 计数
print(fruits_tuple.count("banana"))     # 2

# 查找
print(fruits_tuple.index("banana"))     # 2

元组在内存上比列表更小，换句话说使用元组可以节省内存，使用sys.getziseof函数可以返回该对象的字节数。
import sys
print(sys.getsizeof((“apple”, “pear”, “peach”, “banana”)))  # 72

print(sys.getsizeof([“apple”, “pear”, “peach”, “banana”]))  # 88

字典 dict

字典是由一个个键值对组成的数据结构，它以大括号（{}）括起来为一个数据，一般的形式为：{“key”: "value}。需要注意的是，字典的键不能重复，也就是说，假如再次给已经存在的键赋值时，原来的值会被替换；而且键是可以被哈希的数据，一般来说，python不可变的内置类型都可以被哈希，而列表和字典是可变的，不可被哈希，所以不能作为集合的元素。。
data = {
    "name": "lczmx",
    "age": 18,
    "address": "xxx",
}

# 获取

# 1. 使用中括号，类似于索引的方法，假如没有该键的话会报错
print(data["name"])                  # lczmx
# 2. 使用get方法,没有该键时，返回另一个参数
print(data.get("name", "none"))      # lczmx

# 3. 获取键值对
for k, v in data.items():
    print(f"key: {k}  value: {v}")

# 4. 获取键或值
for k in data.keys():
    print(f"key: {k}")

for v in data.values():
    print("value: %s" % v)


# 更新
# 1. update
data.update({"score": 99, "student": True})				# 写法一
data.update(score=99, student=True)						# 写法二
# {'name': 'lczmx', 'age': 18, 'address': 'xxx', 'score': 99, 'student': True}

# 2. fromkeys
# 将一个可迭代的数据的元素作为键，为多个键创建统一的值
# 注意，这是dict的方法
d2 = dict.fromkeys(["a", "b", "c"], "123")
print(d2)               # {'a': '123', 'b': '123', 'c': '123'}

# 3. setdefault
# 存在取对应的值，不存在则新增键值对
print(data.setdefault("name", "lczmx"))     # lczmx

# 删除
# 1. 随机删除,返回被删除的键值对
print(data.popitem())       # ('student', True)

# 2. 删除键对应的值，不存在时返回的二个参数

print(data.pop("name", "already delete"))       # lczmx

# 3. 清空
data.clear()
print(data)		# {}
集合 set
python的集合与数学上的集合是一样的，有交集、差集、并集、补集等操作，而且元素是唯一无序的。注意：元素的类型不可变的，准确的说：可以被哈希的数据类型可成为元素。根据集合的这些特性，一般来说其用途一般有两个方面：1. 关系测试（相交等）、2. 去重。

fruits1 = {'cherry', 'pear', 'banana', 'watermelon', 'lemon'}
fruits2 = set(['apple', 'pear', 'banana', 'orange'])


# 添加
fruits2.add("lemon")

# 交差并集可以用方法实现，也可以用符号实现
# 交集
print(fruits1.intersection(fruits2))
print(fruits1 & fruits2)
# {'banana', 'lemon', 'pear'}


# 差集
print(fruits1.difference(fruits2))
print(fruits1 - fruits2)
# {'watermelon', 'cherry'}

# 并集

print(fruits1.union(fruits2))
print(fruits1 | fruits2)

# {'banana', 'orange', 'pear', 'cherry', 'watermelon', 'lemon', 'apple'}


# 删除
# 1. remove
# 删除指定元素，不存在则报错
fruits1.remove("banana")

# 2. discard
# 删除指定元素，不存在不报错
fruits1.discard("apple")

假如定义的时候用forzenset定义的话，则该集合不可变。
推导式

推导式是一种构建数据的快捷方式，假如用得好可以简化代码，提高可读性。但假如滥用推导式，就有可能降低代码可读性。一般来说，超过两个for循环的代码，就不适合用推导式了，而直接用多个循环写了。
列表推导式

顾名思义，即生成列表的推导式，和定义列表一样，列表推导式用中括号包裹着表达式。

假如有这样一个需求：

把num = [18, 22, 23, 50]里面的数加一，我们固然可以，使用一个for循环把每个元素加一，然后放回原来的列表中。但使用列表推到式只需要一行代码即可：num = [n + 1 for n in num]。

上面的例子只有一个循环，但假如多个循环该怎么做，如果现在有num和code两个列表：
num = [1, 2, 3, 4, 5]
code = ["A", "B", "C", "D"]

要求他们相互组合成[‘A1’, ‘A2’, ‘A3’, ‘A4’, ‘A5’, ‘B1’, ‘B2’, ‘B3’, ‘B4’, ‘B5’, ‘C1’, ‘C2’, ‘C3’, ‘C4’, ‘C5’, ‘D1’, ‘D2’, ‘D3’, ‘D4’, ‘D5’]。

很简单：
num = [1, 2, 3, 4, 5]
code = ["A", "B", "C", "D"]


result = [c + str(n) for c in code for n in num]
print(result)

python2.7的版本中使用列表推导式有可能有变量泄露的风险，但在python3中则没有该顾虑，可以放心使用。
生成器表达式

虽然可以使用列表推导式初始化元组等其它序列类型，但是生成器表达式是更好的选择。由于生成器遵循迭代器协议，可以在用到时才生成元素，可以减少内存开销。生成器表达式在书写上与列表推导式仅仅是把中括号换成了小括号。

比如同样是上面的那个例子：
import sys


num = [1, 2, 3, 4, 5]
code = ["A", "B", "C", "D"]


result_list = [c + str(n) for c in code for n in num]
result_tuple = tuple([c + str(n) for c in code for n in num])
result_gen = (c + str(n) for c in code for n in num)

print(sys.getsizeof(result_list), sys.getsizeof(
    result_tuple), sys.getsizeof(result_gen))
# 256 200 112

使用生成器除了可以用生成器表达式，也可以用yeild关键字：
def gen_result():
    num = [1, 2, 3, 4, 5]
    code = ["A", "B", "C", "D"]
    for c in code:
        for n in num:
            yield c + str(n)


for i in gen_result():
    print(i)

字典推导式

自python2.7以来，列表推导式和生成器表达式的python基础教程概念就移植到了字典上（集合也一样），因此就有了字典推导式。使用字典推导式可以将可迭代的数据作为键值对构建出字典。

例子：
temp = ["A1", "B2", "C3", "D4"]

result_dict = {c: n for c, n in temp}
print(result_dict)      # {'A': '1', 'B': '2', 'C': '3', 'D': '4'}

假如是由两个可迭代数据组成字典的话，可以使用zip函数：
num = ["1", "2", "3", "4"]
code = ["A", "B", "C", "D"]


result_dict = dict(zip(code, num))
print(result_dict)      # {'A': '1', 'B': '2', 'C': '3', 'D': '4'}

集合推导式

集合推导式跟列表推导式用起来c#教程差不多，下面举个简单的例子即可：
num = ["1", "2", "3", "4"]
code = ["A", "B", "C", "D"]


result_set = {c + str(n) for c in code for n in num}
print(result_set)

# {'D3', 'C3', 'A2', 'D1', 'C1', 'C2', 'B4', 'B2', 'B3', 'C4', 'A1', 'D2', 'D4', 'A3', 'B1', 'A4'}

练习

在屏幕上显示跑马灯文字。

import time
def main():
    string = "放飞你的青春，奔洒你的热情。       "
    while True:
        print("\r%s" % string, end="")
        string = string[1:] + string[0]	# 把第一个字符放到最后一个，以达到

运动的效果

time.sleep(0.2)
if __name__ == '__main__':
    main()

设计一个函数产生指定长度的vb.net教程
验证码，验证码由大小写字母和数字构成。
import random


def veri_code(count=4):
    chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
    temp = ""
    for _ in range(count):
        temp += random.sample(chars, 1)[0]
    return temp


def main():
    print(veri_code())


if __name__ == '__main__':
    main()
设计一个函数返回给定文件名的后缀名。
def get_suffix(filename):
    if "." in filename:
        return filename.split(".")[-1]
    else:
        return ""
设计一个函数返回传入的列表中最大和第二大的元素的值。
def get_max(data: list):
    max1 = 0    # 最大
    max2 = 0    # 第二大
    for d in data:
        if d > max1:
            max2 = max1
            max1 = d
        else:
            if d > max2:
                max2 = d
    return max1, max2
打印杨辉三角。
def triangles():
    L = [1]
    while True:
        yield L
        L = [sum(i) for i in zip([0] + L, L + [0])]		# zip和sum结合，不过要在两边加0