跟着大王学Python－基础学习（Day1）

Ctry

这么多年来一直有打算整理一个自己的博客，从WordPress、51Cto、blog163等等这些没有一个我坚持写下去的，反思其结果总有这样或者那样的一些借口来进行自我辩护，其实自己内心深处是知道最原始的问题。今天是我学习Python的第一天，正如老师所说的写好一个blog可以让很多人知道你，关注你。为了实现这一目标，我又开始了我的blog生涯~，我希望这是我最后申请的一个博客，我要用它来记录我的成长之路，同时也给自己一个警示。目标是需要脚踏实地一步一步去走过，而不是想想就能实现的。~开源的心很重要~ ~分享也很重要~ ~思想更重要~ Come On

1. Python2.x和Python3.x的主要区别说明（化繁为简）

Print函数

Py2中的print语句被Py3中的print()函数取代，也就是Py3中必须用括号来将需要输出的对象括起来。

另外在Py2中使用额外的括号来调用也是可以的，但反过来在Py3中想以Py2的形式不带括号调用print函数时，会触发SyntaxError。

 1 >>> from platform import python_version
 2 >>> print "This is Old Version", python_version()
 3 This is Old Version 2.7.10
 4 >>> print "Hello, World!"
 5 Hello, World!
 6 >>> print ("Hello, World!")
 7 Hello, World!
 8 >>> print (‘Hello, World!‘)
 9 Hello, World!
10 >>> print (2,3)
11 (2, 3)
12 
13 >>> from platform import python_version
14 >>> print("This is Version", python_version())
15 This is Version 3.5.1
16 >>> print(‘Hello, World!‘)
17 Hello, World!
18 
19 # 自定义项目之间分隔符
20 >>> print("There are <", 2**32, "> possibilities!", sep="")
21 There are <4294967296> possibilities!
22 
23 # 追加新行
24 >>> print(x)
25 Hello, World!
26 >>> print(x, end=" ")
27 >>> print(x)
28 Hello, World! Hello, World!
29 >>> print(2,3)
30 2 3
31 >>> print((2,3))
32 (2, 3)

猛戳它

Unicode

Py2有基于ASCII的str()类型，可以通过单独的Unicode()函数转换unicode类型，但没有byte类型。

而在Py3中，终于有了Unicode（utf-8）字符串，以及两个字节类：bytes和bytearrays

 1 # -*- coding:utf-8 -*-
 2 >>> from platform import python_version
 3 >>> print "This is Old Version", python_version()
 4 This is Old Version 2.7.10
 5 >>> print "您好，世界！" 
 6 
 7 >>> from platform import python_version
 8 >>> print("This is Version", python_version())
 9 This is Version 3.5.1
10 >>> print("您好，世界！")
11 您好，世界！

猛戳它

整数除法

1 print ‘3 / 2 =‘, 3 / 2
2   3 / 2 = 1
3 
4 print(‘3 / 2 =‘, 3 / 2)
5   3 / 2 = 1.5

猛戳它

input()解析用户的输入

Py3改进了input()函数，这样该函数就会总是将用户的输入存储为str对象。在Py2中，为避免读取非字符串类型会发生的一些危险行为，不得不使用raw_input()来代替input()。

 1 >>> from platform import python_version
 2 >>> print "This is Old Version", python_version()
 3 This is Old Version 2.7.10
 4 
 5 >>> lucky_number = input(‘Please Input Your Lucky Number: ‘)
 6 Please Input Your Lucky Number: 4710
 7 
 8 >>> type(lucky_number)
 9 <type ‘int‘>
10 
11 >>> lucky_number = raw_input(‘Please Input Your Lucky Number: ‘)
12 Please Input Your Lucky Number: 3289
13 
14 >>> type(lucky_number)
15 <type ‘str‘>
16 
17 >>> from platform import python_version
18 >>> print("This is Version", python_version())
19 This is Version 3.5.1
20 
21 >>> lucky_number = input(‘Please Input Your Lucky Number: ‘)
22 Please Input Your Lucky Number: 3289
23  
24 >>> type(lucky_number)
25 <type ‘str‘>

猛戳它

迭代对象返回

Py2中，range通常返回对象全部列表，而Py3中，range只返回列表的头和尾，这种方式会节省很多内存，但是通过生成器来多次迭代这些对象，效率相对就不太高了。

 1 >>> from platform import python_version
 2 >>> print "This is Old Version", python_version()
 3 This is Old Version 2.7.10
 4 
 5 >>> print range(3)
 6 >>> print type(range(3))
 7  
 8 [0, 1, 2]
 9 <type ‘list‘>
10 
11 >>> print(range(3))
12 range(0, 3)
13 >>> print(type(range(3)))
14 <class ‘range‘>
15 >>> print(list(range(3)))
16 [0, 1, 2]
17 
18 扩展迭代
19 >>> (a, *rest, b) = range(5)
20 >>> a
21 0
22 >>> b
23 4
24 >>> rest
25 [1, 2, 3]

猛戳它

Ok，区别就介绍到这里吧，更多区别可参见python官网。

2. Python3.0的使用

打印一条输出

1 >>> print("Python Ver: ", python_version())
2 Python Ver:  3.5.1
3 >>> print("Hello, World!")
4 Hello, World!
5 >>> print("Hello, World!\n" "I have a dream!")
6 Hello, World!
7 I have a dream!

猛戳它

缩进

在其它的语言中可能通过｛｝来区分代码段的执行，那么在Python中是通过缩进来进行分层执行的，一般在同一层执行的代码段缩进间隔需要一样，否则会报错(IndentationError)缩进错误。官方建议4空格。

 1 >>> x = 1
 2 >>> if x == 1:
 3  ...     print("x is 1.")
 4  ...     
 5  x is 1.
 6 
 7 >>> if x == 1:
 8 ...     print("x is 1.")
 9 ...  print("false")
10 ...  
11   File "<input>", line 3
12     print("false")
13                  ^
14 IndentationError: unindent does not match any outer indentation level
15 >>> if x == 1:
16 ...     print("x is 1.")
17 ...     print("false")
18 ...     
19 x is 1.
20 false

猛戳它

脚本执行

 1 直接使用python命令执行
 2 python3.5 FirstProgram.py 
 3 或者
 4 chmod +x hello.py ＃ 给脚本加上可执行权限，然后直接./hello.py，但是需要做下面的操作，在脚本开始声明解释器。
 5 
 6 #!/usr/bin/python
 7 或者
 8 #!/usr/bin/env python3.5 # 必须声明使用哪个解释器来执行此脚本
 9 
10 推荐第二种，在装有两个版本的Py时比较灵活查找。
11 #cat hello.py 
12 #!/usr/bin/env python3.5
13 (a, *rest, b) = range(5)
14 print(a)
15 print(rest)
16 print(b)
17 
18 #./hello.py 
19 [1, 2, 3]

猛戳它

变量

 1 声明变量
 2 >>> from platform import python_version
 3 >>> print("Python Ver: ",python_version())
 4 Python Ver:  3.5.1
 5 >>> name = "A"
 6 
 7 上述代码声明了一个变量，变量名为：name，变量name的值为："A"
 8 变量的作用：昵称，即内存中的某个地址中所保存的内容。 id() 查看内存地址
 9 
10 变量起名
11     1. 显式 － 通俗易懂
12     2. nums_of_alex_gf ＝ 19
13     3. NumsOfAlexGf ＝ 2
14 
15     4. names-of-alex-ge = 22 不推荐
16     5. 5name = 数字不能开头
17     6. 特殊字符不能有
18     7. 空格不能有
19     8. 关键字不能声明为变量
20 
21 变量的赋值
22 如name1的值为A，name2的值为B，当name2等于name1的时候，name1的值就赋值给了name2，也就是name1和name2都同时将标示指到了A，这个时候B值没有任何去做关联，那么B就会被回收掉。
23 >>> name1 = "A"
24 >>> name2 = "B"
25 >>> 
26 >>> name1
27 ‘A‘
28 >>> name2
29 ‘B‘
30 >>> 
31 >>> name2 = name1
32 >>> name1
33 ‘A‘
34 >>> name2
35 ‘A‘
36 
37 >>> id(name1)
38 >>> id(name2)
39 我们可以看到name1和name2在内存中所指的地址是同一个地址。

猛戳它

用户交互

#!/usr/bin/env python3.5

# 将用户输入的内容赋值给 name 的变量

name = input("请输入你的用户名: ")

# 打印输出的内容

print(name)

请输入你的用户名: Ctry
Ctry

小技巧：

注释代码
‘‘‘
# 将用户输入的内容赋值给 name 的变量

name = input("请输入你的用户名: ")

# 打印输出的内容

print(name) ‘‘‘

或者
Mac：commond+/
Win：ctrl+/
#!/usr/bin/env python3.5
# 
# # 将用户输入的内容赋值给 name 的变量
# 
# name = input("请输入你的用户名: ")
# 
# # 打印输出的内容
# 
# print(name)

猛戳它

1 输入密码时达到不可见效果，需要利用getpass模块中的getpass方法调用，如下：
2 >>> import getpass
3 >>> pwd = getpass.getpass("Please Input Your Password:")
4 Please Input Your Password:
5 >>> print(pwd)
6 123456

猛戳它

条件语句和缩进使用

案例一：提示用户输入用户名和密码

 1 #!/usr/bin/env python3.5
 2 
 3 # 提示用户输入用户名和密码
 4 
 5 # 验证用户名和密码
 6 #       如果错误,需要打印出用户名或密码错误
 7 #       如果成功,则输出欢迎,某某某!
 8 
 9 import getpass
10 
11 name = input("请输入你的用户名: ")
12 pwd = getpass.getpass("请输入你的用户名密码: ")
13 
14 if name == "Ctry" and pwd == "chen":
15     print(‘欢迎您,Ctry!‘)
16 else:
17     print(‘用户名和密码错误!‘)
18 
19 
20 python3.5 if_input.py 
21 请输入你的用户名:         Ctry
22 请输入你的用户名密码: 
23 欢迎您,Ctry!

猛戳它

案例二：提示用户猜幸运数（由浅入深）

 1 #!/usr/bin/env python3.5
 2 
 3 # 猜Lucky Number,n=10
 4 # 猜的数字 比10大,提示比真实数字小一点
 5 # 猜的数字 比10小,提示比真实数字大一点
 6 # 猜的数字 等于10,提示Bingo
 7 
 8 lucky_number = 10
 9 input_number = int(input("Please input the guess number: "))
10 if input_number == lucky_number:
11     print("Bingo!")
12 elif input_number > lucky_number:
13     print("the real number is smaller.")
14 else:
15     print("the real number is bigger.")

猛戳它

Q&A：找BUG，按照上面脚本的逻辑，用户不管时输入比10小还是比10大的数都会提示完后直接退出，这样以来就显得有些不太友好，下面我们来改进上面的脚本，切入点（让用户尝试多次输入）

 1 #!/usr/bin/env python3.5
 2 
 3 # 猜Lucky Number,n=10
 4 # 猜的数字 比10大,提示比真实数字小一点
 5 # 猜的数字 比10小,提示比真实数字大一点
 6 # 猜的数字 等于10,提示Bingo
 7 
 8 lucky_number = 10
 9 while True: # 利用while循环来实现
10     input_number = int(input("Please input the guess number: "))
11     if input_number == lucky_number:
12         print("Bingo!")
13     elif input_number > lucky_number:
14         print("the real number is smaller.")
15     else:
16         print("the real number is bigger.")

猛戳它

Q&A：找BUG，按照上面脚本的逻辑，用户不管输入的是什么都会一直提示输入，那么对于用户来说，OMG 这什么鬼！下面我们来改进上面的脚本，切入点（让用户输入正确时候就退出）

 1 #!/usr/bin/env python3.5
 2 
 3 # 猜Lucky Number,n=10
 4 # 猜的数字 比10大,提示比真实数字小一点
 5 # 猜的数字 比10小,提示比真实数字大一点
 6 # 猜的数字 等于10,提示Bingo
 7 
 8 lucky_number = 10
 9 while True:
10     input_number = int(input("Please input the guess number: "))
11     if input_number == lucky_number:
12         print("Bingo!")
13         break # 利用break来中断循环
14     elif input_number > lucky_number:
15         print("the real number is smaller.")
16     else:
17         print("the real number is bigger.")

猛戳它

 1 #!/usr/bin/env python3.5
 2 
 3 # 猜Lucky Number,n=10
 4 # 猜的数字 比10大,提示比真实数字小一点
 5 # 猜的数字 比10小,提示比真实数字大一点
 6 # 猜的数字 等于10,提示Bingo
 7 
 8 lucky_number = 10
 9 input_number = -1
10 while lucky_number != input_number: #利用设定input_number初始值，在while时进行判断，通过在while层实现输入正确值退出
11     input_number = int(input("Please input the guess number: "))
12     if input_number > lucky_number:
13         print("the real number is smaller.")
14     elif input_number < lucky_number:
15         print("the real number is bigger.")
16 print("Bingo!")

猛戳它

Q&A：找BUG，按照上面脚本的逻辑，用户如果一直输入错误的数字，OMG 还是一个死循环！下面我们来改进上面的脚本，切入点（限制用户输入次数，达到3此后退出并友好提示，正确之后正常退出）

 1 #!/usr/bin/env python3.5
 2 
 3 # 猜Lucky Number,n=10
 4 # 猜的数字 比10大,提示比真实数字小一点
 5 # 猜的数字 比10小,提示比真实数字大一点
 6 # 猜的数字 等于10,提示Bingo
 7 
 8 lucky_number = 10
 9 guess_count = 0 # 增加计数器初始值
10 while guess_count < 3: # 计数器的数值判断
11     input_number = int(input("Please input the guess number: "))
12     if input_number > lucky_number:
13         print("the real number is smaller.")
14     elif input_number < lucky_number:
15         print("the real number is bigger.")
16     else:
17         print("Bingo!")
18         break
19     guess_count += 1    # 计数器做累加操作
20 else:
21     print("Too Many Retrys!")

猛戳它

 1 #!/usr/bin/env python3.5
 2 
 3 # 猜Lucky Number,n=10
 4 # 猜的数字 比10大,提示比真实数字小一点
 5 # 猜的数字 比10小,提示比真实数字大一点
 6 # 猜的数字 等于10,提示Bingo
 7 
 8 lucky_number = 10
 9 
10 for i in range(3): # for循环直接搞定
11     input_number = int(input("Please input the guess number: "))
12     if input_number > lucky_number:
13         print("the real number is smaller.")
14     elif input_number < lucky_number:
15         print("the real number is bigger.")
16     else:
17         print("Bingo!")
18         break
19 else:
20     print("Too Many Retrys!")

猛戳它

数据类型

Python的基本数据类型有5种：整数（int）、浮点数（float）、字符串（string）、布尔值（bool）、空值（None）。

整数

通常被称为只是整数或整数，是正或负整数，不带小数点。

在32位的机器上，整数的位数为32位，取值范围为-2**31~2**31-1，即-2147483648~2147483647

在64位的机器上，整数的位数位64位，取值范围为-2**63~2**63-1，即-9223372036854775808~9223372036854775807

长整数

Python没有限制长整数数值的大小，但由于各个机器的内存有限，我们使用长整数数值就不可能无限大。

Note：从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整型，所以如今在长整数数据后面不加字母L也不会导致严重后果。

浮点数

浮点数也就是小数，之所以为浮点数，是因为按照科学计数法表示时，一个浮点数的小数点位置是可变的。例如：1.5, 2.3, －0.1，另外浮点数占8个字节（64位）

布尔值

布尔值和布尔代数表示一样，一个布尔值分为True、False两种值。

1 >>> True
2 True
3 >>> False
4 False
5 >>> 3>2
6 True
7 >>> 3>4
8 False

猛戳它

字符串

字符串是以单引号或双引号括起来的任意文本，比如"string", "full"，单引号和双引号只是一种表示方法，不属于字符串中的一部分，如需要单引号也是一个字符，那么就需要用双引号再括一层来表示。

1 >>> "Hello,World"
2 ‘Hello,World‘
3 >>> "Hello, ‘World!‘"
4 "Hello, ‘World!‘"

猛戳它

如需要单双引号都当成字符串的一部分来表示，那么就使用\转译。

　　字符串格式化

 1 name = "ctry"
 2 age = int(25)
 3 job = "IT"
 4 
 5 print("Information of %s: \nName: %s\nAge: %s\nJob: %s" %(name, name, age, job))
 6 
 7 Information of ctry: 
 8 Name: ctry
 9 Age: 25
10 Job: IT

猛戳它

 1 name = "ctry"
 2 age = int(25)
 3 job = "IT"
 4 
 5 msg = ‘‘‘
 6 Information of %s:
 7     Name:%s
 8     Age:%s
 9     Job:%s
10 ‘‘‘ % (name, name, age, job)
11 print(msg)
12 
13 Information of ctry:
14     Name:ctry
15     Age:25
16     Job:IT
17 
18 PS：字符串是%s , 整数是%d , 浮点是%f，另外可以用‘‘‘ """来自定义格式，同时方便阅读

猛戳它

字符串常用功能：（移除空白、分割、长度、索引、切片）

 1 name = input("name:").strip()
 2 age = int(input("age:"))
 3 job = input("job:").strip()
 4  
 5  
 6 msg = ‘‘‘
 7 Information of %s:
 8      Name:%s
 9      Age:%s
10      Job:%s
11  ‘‘‘ % (name, name, age, job)
12  print(msg)
13  
14  name:     ctry
15  age:   34
16  job:I T
17  
18  Information of ctry:
19      Name:ctry
20      Age:34
21      Job:I T
22 
23 s.strip(rm)     删除s字符串中开头、结尾处，位于 rm删除序列的字符
24 s.lstrip(rm)    删除s字符串中开头处，位于 rm删除序列的字符
25 s.rstrip(rm)    删除s字符串中结尾处，位于 rm删除序列的字符
26 
27 当rm为空时，默认删除空白符（包括‘\n‘ ‘\r‘ ‘\t‘ ‘‘）

猛戳它

数据列表

 1 >>> name_list = ["shuqi", "liuan", "wangwu", "zhangshan", "78brother"]
 2 >>> name_list
 3 [‘shuqi‘, ‘liuan‘, ‘wangwu‘, ‘zhangshan‘, ‘78brother‘]
 4 >>> dir(name_list) # 查找列表操作
 5 可用如： [‘append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘]
 6 
 7 依次为：追加、清除、复制、统计、扩展、索引、插入、从后删除一个元素、删除任意指定元素、反转整个列表、排序（字符串，数字）
 8 
 9 >>> name_list.append("wangzhaojun") # 添加一个元素到列表
10 >>> name_list
11 [‘shuqi‘, ‘liuan‘, ‘wangwu‘, ‘zhangshan‘, ‘78brother‘, ‘wangzhaojun‘]
12 
13 >>> name_list.pop() # 从列表尾部删除一个元素
14 ‘wangzhaojun‘
15 >>> name_list
16 [‘shuqi‘, ‘liuan‘, ‘wangwu‘, ‘zhangshan‘, ‘78brother‘]
17 
18 >>> name_list.insert(3,"wangzx") # 在列表的第3个索引位插入一个元素
19 >>> name_list
20 [‘shuqi‘, ‘liuan‘, ‘wangwu‘, ‘wangzx‘, ‘zhangshan‘, ‘78brother‘]
21 
22 >>> name_list.sort(key=None, reverse=False) # 排序
23 >>> name_list
24 [‘78brother‘, ‘liuan‘, ‘shuqi‘, ‘wangwu‘, ‘wangzx‘, ‘zhangshan‘]
25 
26 切片排序，3.x默认字符串和数字不能进行排序，需要切片后进行排序
27 >>> name_list[-4:]
28 [1, 3, 2, 6]
29 >>> name_sort = name_list[-4:]
30 >>> name_sort.sort()
31 >>> name_sort
32 [1, 2, 3, 6]
33 >>> name_list[:8]
34 [‘78brother‘, ‘liuan‘, ‘shuqi‘, ‘shuqi‘, ‘shuqi‘, ‘wangwu‘, ‘wangzx‘, ‘zhangshan‘]
35 >>> name_name = name_list[:8]
36 >>> name_name.sort()
37 >>> name_name
38 [‘78brother‘, ‘liuan‘, ‘shuqi‘, ‘shuqi‘, ‘shuqi‘, ‘wangwu‘, ‘wangzx‘, ‘zhangshan‘]
39 >>> name_name.sort(key=None, reverse=False)
40 >>> name_name
41 [‘78brother‘, ‘liuan‘, ‘shuqi‘, ‘shuqi‘, ‘shuqi‘, ‘wangwu‘, ‘wangzx‘, ‘zhangshan‘]
42 
43 批量删除包涵shuqi的元素
44 >>> name_name
45 [‘78brother‘, ‘liuan‘, ‘shuqi‘, ‘shuqi‘, ‘shuqi‘, ‘wangwu‘, ‘wangzx‘, ‘zhangshan‘]
46 >>> for i in range(name_name.count("shuqi")):
47 ...     name_name.remove("shuqi")
48 ...     
49 >>> name_name
50 [‘78brother‘, ‘liuan‘, ‘wangwu‘, ‘wangzx‘, ‘zhangshan‘]
51 
52 判断包涵
53 >>> "liuan" in name_name
54 True
55 >>> 4 in name_name
56 False
57 
58 >>> if "liuan" in name_name:
59 ...     print("Yes")
60 ... else:
61 ...     print("No")
62 ...     
63 Yes

猛戳它

数据元组

 1 >>> ages = (11, 22, 33, 4, 18, 60)
 2 >>> dir(ages)
 3 [ ‘count‘, ‘index‘] # 依次为统计、索引
 4 
 5 元组和列表转换
 6 >>> type(ages)
 7 <class ‘tuple‘>
 8 >>> list_ages = list(ages)
 9 >>> type(list_ages)
10 <class ‘list‘>
11 >>> type(name_name)
12 <class ‘list‘>
13 >>> a = tuple(name_name)
14 >>> type(a)
15 <class ‘tuple‘>
16 
17 判断
18 >>> if 11 in ages:
19 ...     print("True")
20 ... else:
21 ...     print("False")
22 ...
23 True
24 >>> 11 not in ages
25 False

猛戳它

运算符

算术运算符
运算符	描述	eg..
+	加（两个对象相加）	>>> 1+2 3
-	减（得到负数结果或者一个数减去另外一个数）	>>> 3-4 -1
*	乘 (两个数相乘)	>>> 4*13 52
%	除 (x除以y)	>>> 4/3 1.3333333333333333
/	取模 (取除法的余数)	>>> 4%3 1
**	幂 (返回x的y次幂)	>>> 4**4 256
//	取整数 (返回商的整数部分)	>>> 9//3 3 >>> 9.0//3.0 3.0

比较运算符
运算符	描述	eg..
==	等于（比较两个对象是否相等）	>>> a==b False
!=	不等于（比较两个对象是否不相等）	>>> a!=b True
>	大于（比较两个数值的大小关系，如a是否大于b）	>>> a>b False
<	小于（比较两个数值的大小关系，如a是否小于b），所有比较运算返回1表示真，返回0表示假，同时与True和False等价。	>>> a<b True
>=	大于等于 (比较两个数值的大小关系，如a是否大于等于b)	>>> a>=b False
<=	小于等于 (比较两个数值的大小关系，如a是否小于等于b)	>>> a<=b True

赋值运算符
运算符	描述	eg..
=	简单的赋值运算符	>>> c=a+b >>> c 30
+=	加法赋值运算符	>>> c+=a or c=c+a >>> c 40
-=	减法赋值运算符	>>> c-=a or c=c-a >>> c 30
*=	乘法赋值运算符	>>> c=a or c=ca >>> c 300
/=	除法赋值运算符	>>> c/=a or c=c/a >>> c 30.0
%=	取模赋值运算符	>>> c%=a or c=c%a >>> c 0.0
**=	幂赋值运算符	>>> a=10 >>> c=30 >>> c=a or c=ca >>> c 590490000000000
//=	取整除赋值运算符	>>> c//=a or c=c//a >>> c 59049000000000

位数运算符
运算符	描述	eg..
&	按照位与运算	>>> a=13 >>> b=15 >>> a&b 13　　二进制解释：0000 1101
\|	按照位或运算	>>> a\|b 15　二进制解释：0000 1111
^	按照位异或运算	>>> a^b 2 二进制解释： 0000 0010
~	按照位取反运算	>>> ~a -14 >>> ~b -16
<<	左移动运算符	>>> a<<2 52 二进制解释： 0011 0100
>>	右移动运算符	>>> a>>2 3 二进制解释： 0000 0011

负数的二进制表示方法

在计算机中，负数以其正值的补码形式表达。
1、先取出原码（一个整数按照绝对值大小转换为二进制，称之为原码）
2、得出反码（将二进制数按位取反，所得的新二进制数位原二进制数的反码）
3、补码（反码+1）

如：-14

二进制原码： 0000 1110
二进制反码： 1111 0001
补码二进制反码+1: 1111 0010

猛戳它

逻辑运算符
运算符	描述	eg..
and	布尔"与"（如果a为False，a and b返回False，否则返回b的计算值）	>>> if a>5 and b<4: ... print("True") ... else: ... print("False") ... False
or	布尔"或"（如果a为True，则返回True，否则返回b的计算值）	>>> if a>5 or b<4: ... print("True") ... else: ... print("False") ... True
not	布尔"非"（如果a为True，则返回False，如果a为False，则返回True）	>>> 4*13 >>> if not(a>5 and b<4): ... print("True") ... else: ... print("False") ... True

成员运算符&身份运算符
运算符	描述	eg..
in	如果在指定的序列中找到值返回True，否则返回False	>>> a=[1,2,3,5] >>> if 1 in a: ... print("True") ... else: ... print("False") ... True
not in	如果在指定的序列中没有找到值返回True，否则返回False	>>> if 1 not in a: ... print("True") ... else: ... print("False") ... False
is	is是判断两个标识符是不是引用自一个对象	>>> name1="ctry" >>> name2="ctry" >>> name1 is name2 True >>> name1 is not name2 False
is not	is not是判断两个标识符是不是引用自不同对象	>>> name1="ctry" >>> name2="monkey" >>> name1 is not name2 True >>> name1 is name2 False

循环

为了让计算机执行多次重复的运算操作，我们需要用到循环语句来达到目的，在Python中循环分为for..in循环和while循环。

FOR 循环（依次将每个元素迭代显示出来）：

1 >>> list = ["zhangsan", "lisi", "wangwu", "qinquan"]
2 >>> for i in list:
3 ...     print(i)
4 ...
5 zhangsan
6 lisi
7 wangwu
8 qinquan

猛戳它

从执行结果我们可以看出，for循环将list数组里的每个元素调入变量i，同时并执行print代码块的操作。

利用for循环进行累加操作：

 1 >>> sum = 0
 2 >>> for num in range(100):
 3 ...     sum = sum + num
 4 ...
 5 >>> print(sum)
 6 4950
 7 
 8 执行0-99的累加操作，若要执行0-100的累加操作，range的范围就需要0-101，如下：
 9 
10 >>> sum = 0
11 >>> for num in range(101):
12 ...     sum = sum + num
13 ...
14 >>> print(sum)
15 5050

猛戳它

While循环（当条件成立那么循环将一直执行，否则条件为假退出循环）：

 1 >>> x = 0
 2 >>> y = 99
 3 >>> while y > 0:
 4 ...     x = x + y
 5 ...     y = y - 2
 6 ...
 7 >>> print(x)
 8 2500
 9 
10 初始值x为0，y为99，如果y大于0，就执行累加操作，同时执行自减操作直到y小于0为负数时，退出整个循环。

猛戳它

将list中的每个名字依次打印出hello, xxx！：

1 >>> list = ["MeiMei", "Davia", "Lili"]
2 >>> for name in list:
3 ...     print("hello, %s!" % name)
4 ...
5 hello, MeiMei!
6 hello, Davia!
7 hello, Lili!

猛戳它

文件操作符初识

打开文件：

　　file = open("file path", "模式")

打开文件的模式有：

　　。 r, 以只读的方式打开文件

　　。 w, 打开一个文件只用于写入。如果文件已经存在则将其覆盖。如果文件不存在，则创建新文件。

　　。 a, 打开一个文件用户追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果文件不存在，则创建新文件进行写入。

　　。 w+, 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果文件不存在，则创建新文件。

1 >>> f = open(‘/Users/HaiZhi/Document/test.txt‘, ‘r‘)
2  
3 # 表示打开/Users/HaiZhi/Document/test.txt的这个文件，如果文件不存在则会报错IOError。

读取文件：

# 上面文件已经打开成功，接下来我们读取文件，默认read()是读取全部的内容。

>>> f.read()
 ‘Hello, world!

写入文件：

 1 >>> file = open("1.txt", "a")
 2 >>> file.write("It\‘s OK!")
 3 8
 4 >>> file.close()
 5 
 6 >>> file = open("1.txt", "r")
 7 >>> for line in file.readlines():
 8 ...     print(line.strip())
 9 ...
10 
11 一级菜单
12 二级菜单
13 三级菜单
14 返回上一级
15 退出
16 It‘s OK!
17 >>> file.close()

猛戳它

关闭文件：

# 当读取完一个文件之后，我们需要调用close()方法来关闭文件，因为文件一直打开会占用系统资源，而且OS同一时间打开的文件数也是有限制的。

>>> f.close()

# 设想一下，当一个文件的大小很大的时候，我们想一次读取全部的内容可能由于资源占用问题导致内存爆掉，为了更合理的读取文件，我们可以调用read(size)，来将指定大小的内容读入内存，或者readlines()读行来调取整个文件并按行来返回操作。

读取规则：
# 如果文件很小，read()一次性读取最方便；如果不能确定文件大小，反复调用read(size)比较保险；如果是配置文件，调用readlines()最方便：

 1 >>> file = open("1.txt", "r")
 2 >>> file.readline().strip()
 3 ‘一级菜单‘
 4 >>> file.readline().strip()
 5 ‘二级菜单‘
 6 >>> file.readline().strip()
 7 ‘三级菜单‘
 8 >>> file.readline().strip()
 9 ‘返回上一级‘
10 >>> file.readline().strip()
11 ‘退出‘
12 >>> file.close()
13 
14 
15 >>> file = open("1.txt", "r")
16 >>> for line in file.readlines(): ＃利用for循环依次输出行
17 ...     print(line.strip())
18 ...
19 
20 一级菜单
21 二级菜单
22 三级菜单
23 返回上一级
24 退出
25 >>> file.close() # 关闭文件

猛戳它