python基础-基本数据类型

一、 运算符

1、算数运算：

ps:

示例1：

python2.7示例

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 #算数运算符
6 from __future__ import division   #python2.x必须引入division模块。python3.x不需要。
7 
8 val = 9 / 2
9 print(val)

执行结果：

1 4.5

 

python3.x示例

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 #算数运算符
6 val = 9 / 2
7 print(val)

执行结果：

1 4.5

 

2、比较运算：

 ps:

1 a = 1 > 5

 

3、赋值运算：

 ps;

1 a = a + 1    a+=1

ps:

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 start = 1
6 start = start + 1  #加 减乘 除 一样
7 print(start)

执行结果：

1 2

 

4、逻辑运算：

 ps:

1 a = 1>6 or 1==1

 

示例

 1 >>> a = 0
 2 >>> if a:print('a')
 3 ...
 4 
 5 >>> a = 1
 6 >>> if a:print('a')
 7 ...
 8 a
 9 
10 >>> False
11 False
12 或
13 >>> True
14 True

 

5、成员运算

ps:

in 的示例： 

指的是这个SB是不是在上面那个字符串中，在就返回Ture

方法一：

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 name = "郑建文"
6 if "建文" in name:
7     print('ok')
8 else:
9     print('Error')

执行结果：

1 ok

 

方法二：

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-      
3 #Author: nulige
4  
5 #成员运算符
6 s = "ALex SB"
7 ret = "SB" in s    #指的是这个SB是不是在上面那个字符串中，在就返回True
8 print(ret)

执行结果：

1 True

 

示例三：

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 #成员运算符
6 s = "ALex SB"
7 ret = "RSB" in s   #指的是这个RSB是不是在上面那个字符串中，如果不在就返回False
8 print(ret)

执行结果：

1 False

 

not in示例

示例一：

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 name = "郑建文"
6 if "文1" not in name:
7     print('1')
8 else:
9     print ('2')

执行结果：

1 1

 

示例二：

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 #粒度大
6 li = ['alex','eric','rain']
7 ret = "alex" not in li    #在里面就是False，不在里面就是Ture
8 print(ret)

执行结果：

1 False

 

6、三元运算

1 result =值1 if 条件 else 值2

如果条件为真：result =值1

如果条件为假 ：sesult =值2

 

示例

 1 >>> a,b,c = 1,3,5
 2 >>> d =a if a >b else c
 3 >>> d
 4 5
 5 >>> d = a if a <b else c
 6 >>> d
 7 1
 8 >>> if a >b:d=a
 9 ... else:d=c
10 ...

 

7、身份运算

 

8、位运算

更多内容：猛击这里

 

 1 #!/usr/bin/python
 2   
 3 a = 60            # 60 = 0011 1100
 4 b = 13            # 13 = 0000 1101
 5 c = 0
 6   
 7 c = a & b;        # 12 = 0000 1100
 8 print "Line 1 - Value of c is ", c
 9   
10 c = a | b;        # 61 = 0011 1101
11 print "Line 2 - Value of c is ", c
12   
13 c = a ^ b;        # 49 = 0011 0001
14 print "Line 3 - Value of c is ", c
15   
16 c = ~a;           # -61 = 1100 0011
17 print "Line 4 - Value of c is ", c
18   
19 c = a << 2;       # 240 = 1111 0000
20 print "Line 5 - Value of c is ", c
21   
22 c = a >> 2;       # 15 = 0000 1111
23 print "Line 6 - Value of c is ", c

*按位取反运算规则(按位取反再加1)   详解http://blog.csdn.net/wenxinwukui234/article/details/42119265

 

九、运算符优先级

更多内容：猛击这里

 

十、bytes类型

Python3中内置类型bytes和str用法及byte和string之间各种编码转换
Python 3最重要的新特性大概要算是对文本和二进制数据作了更为清晰的区分。文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes，正是这使得两者的区分特别清晰。你不能拼接字符串和字节包，也无法在字节包里搜索字符串（反之亦然），也不能将字符串传入参数为字节包的函数（反之亦然）.

 

bytes to string 字符类型转换

 

说明：字符串转（string)转成bytes类型，再转成string。

示例

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: huzhihua
4 
5 #import login
6 msg = "我爱北京天安门"
7 print(msg)
8 print(msg.encode(encoding="utf-8"))
9 print(msg.encode(encoding="utf-8").decode(encoding="utf-8"))

执行结果：

1 我爱北京天安门
2 b'\xe6\x88\x91\xe7\x88\xb1\xe5\x8c\x97\xe4\xba\xac\xe5\xa4\xa9\xe5\xae\x89\xe9\x97\xa8'
3 我爱北京天安门

 

十一、进制

16位数表示方法

 

16进制与二进制对应关系

 

 二进制转换成十六进制的方法：取四合一法，即从二进制的小数点为分界点，向左（或向右）每四位取成一位

                                       图1

 

组分好以后，对照二进制与十六进制数的对应表（如图1中所示），将四位二进制按权相加，得到的数就是一位十六进制数，然后按顺序排列，小数点的位置不变哦，最后得到的就是十六进制数哦，如图2所示。

                                                  图2

 注意16进制的表示法，用字母H后缀表示，比如BH就表示16进制数11；也可以用0X前缀表示，比如0X23就是16进制的23.直观表示法如图3所示。

 

                                     图3

这里需要注意的是，在向左（或向右）取四位时，取到最高位（最低位）如果无法凑足四位，就可以在小数点的最左边（或最右边）补0，进行换算，如图4所示。

                               图4

 

下面看看将16进制转为二进制，反过来啦，方法就是一分四，即一个十六进制数分成四个二进制数，用四位二进制按权相加，最后得到二进制，小数点依旧就可以啦。如图5所示。

                                     图5

 

在线任意进制转换计算器地址： http://jinzhi.supfree.net/

 

十一、一切皆对象

 对于Python，一切事物都是对象，对象基于类创建

所以，以下这些值都是对象： "wupeiqi"、38、['北京', '上海', '深圳']，并且是根据不同的类生成的对象。

 二、基本数据类型

1、数字：1231

 ps:

     age = 18

 

2、int(整型)

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647，而.在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

ps:

 1 数字  int ，所有的功能，都放在int里
 2 a1 = 123
 3 a1 = 456

 

1、将字符串转换为数字

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-      
3 #Author: nulige
4  
5 a = "123"
6 print(type(a),a)  #输出他是什么类型，并转换为数字
7 
8 b = int(a)
9 print(type(b),b)  #输出他是什么类型，并转换为数字

执行结果：

1 (<type 'str'>, '123')
2 (<type 'int'>, 123)

 

2、把这个字符串以16进制的方式转成10进制

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-      
 3 #Author: nulige
 4 
 5 #二进制表示方法：
 6 #00   10    11    #二进制
 7 #1     2     3    #十进制
 8 #把这个字符串以16进制的方式，转成10进制
 9 num = "0011"   #字符串
10 int(num)
11 v = int(num, base=2)    #base=2  以二进制的方式进行
12 v = int(num, base=16)   #base=16 就是转成16进制
13 print(v)

执行结果：

1 17

 

3、将16进制转成10进制

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-      
3 #Author: nulige
4 
5 #把b以16进制的方式转成10进制
6 num = "b"
7 v = int(num,base=16)
8 print(v)

执行结果：

1 11

常识：

1个字节=8位

1个汉字=3个字节

gb2312=2汉字

utf-8=3汉字（表示：最少3个汉字）

 

4、当前数字的二进制，至少用n位表示

1 #当前数字的二进制，至少用n位表示
2 age = 5
3 # 1  1     #表示二进制，用几位表示
4 # 2  10
5 # 3  11
6 # 4  100
7 # 5  101
8 r = age.bit_length()
9 print(r)

执行结果：

1 3  #表示位数

 

2、字符串：

     表示方法：

　　a1 = "asdf"                         #第一种 “”

　　a1 = ‘ffa’                            #第二种‘’

　　a1 ="""assdfafdsafdas"""     #第三种“““ ”””

 

1、首字母大写：capitalize() 

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-      
3 #Author: nulige
4 
5 #首字母大写
6 test = "aLex"
7 v = test.capitalize()   #首字母大写
8 print(v)

执行结果：

1 Alex

 

2、功能：所有变小写

二者对比：casefold更牛逼，很多未知的对相应变小写

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-      
 3 #Author: nulige
 4 
 5 #所有变小写，casefold更牛逼，很多未知的对相应变小写
 6 test = "aLex"
 7 v1 = test.casefold()
 8 print(v1)
 9 v2 = test.lower()
10 print(v2)

执行结果：

1 alex
2 alex

 

3、设置宽度并将内容居中

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #Author: nulige
 4 
 5 # 3、设置宽度并将内容居中
 6 # 20代指总长度
 7 # * 代表空白未知填充 ，一个字符，可有可无
 8 a1 = "alex"
 9 ret = a1.center(20, '*')
10 print(ret)

执行结果：

1 ********alex********

 

4、去字符串中寻找，寻找子序列出现的次数

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 # 去字符串中寻找，寻找子序列出现的次数
6 a1 = "alex is alph"
7 ret = a1.count("a")
8 ret = a1.count("al",0,10)
9 print(ret)

执行结果：

1 2

 

5、查看是否已什么结尾

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #Author: nulige
 4 
 5 # 查看是否已什么结尾
 6 # 查看是否已什么开始
 7 name = "xiaoMing"
 8 v = name.endswith('g')
 9 v1 = name.startswith('e')
10 print(v)
11 print(v1)

执行结果：

1 True
2 False

 

6、从开始往后面找，找到第一个之后，获取其位置，未找到返回一个-1

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #Author: nulige
 4 
 5 # 6、从开始往后面找，找到第一个之后，获取其位置，未找到返回一个-1
 6 name = "xiaoming"
 7 v = name.find('ao',2,6)#从那个位置开始找  前面的是大于等于 后面是小于
 8 # print(v)
 9 name = "xiaoming"   #index 用法同find 但是如果index找不大值直接报错
10 v = name.index("ming")
11 print(v)

执行结果：

1 4

 

7、格式化输出,将一个字符串中的占位符替换为指定的值

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #Author: nulige
 4 
 5 #格式化输出,将一个字符串中的占位符替换为指定的值
 6 test = 'i am  {name},age {a}'
 7 print(test)
 8 v = test.format(name = 'xiaoming',a = 24)
 9 print(v)
10 test = 'i am  {0},age {1}'
11 print(test)
12 v = test.format('xiaoming',24)
13 print(v)

执行结果：

1 i am  {name},age {a}
2 i am  xiaoming,age 24
3 i am  {0},age {1}
4 i am  xiaoming,age 24

 

9、test.format_map的方法类似format 区别如下图

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #Author: nulige
 4 
 5 #test.format_map的方法类似format 区别如下图
 6 test = 'i am  {name},age {a}'
 7 print(test)
 8 v = test.format(name = 'xiaoming',a = 24)
 9 v1 = test.format_map({"name":"xiaoming","a":19})
10 print(v)
11 print(v1)

执行结果：

1 i am  {name},age {a}
2 i am  xiaoming,age 24
3 i am  {0},age {1}
4 i am  xiaoming,age 24

 

9、判段字符串中是否只包含字母和数字

1 name = "uuuuaa888"
2 v = name.isalnum()
3 print(v)

执行结果:

1 True

 

10、expandtabs,断句20，\t表示六个字符，不够的空格补齐6个。

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 #expandtabs,断句20，\t表示六个字符，不够的空格补齐6个。
6 test = "username\temail\tpassword\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123"
7 v = test.expandtabs(20)
8 print(v)

执行结果：

1 username            email               password
2 laiying             ying@q.com          123
3 laiying             ying@q.com          123
4 laiying             ying@q.com          123

 

 

 

3、long（长整型）

为什么会有这个概念呢？

因为在Python2.2起，如果放置在内存里的数特别大发生溢出，Python就会自动将整型数据转换为长整型，但是现在，在Python3里就不存在长整型这么一说了，同意都是整型。

 

4、float（浮点型）

简单理解就是带有小数的数字

 

5、complex（复数）

复数是由实数部分和虚数部分组成，一般形式为x+yj，其中的x是复数的实数部分，y呢是复数的虚数部分，这里的x和y都是实数。

 

5、布尔值（0或1）

就是真和假。

True/False

a4 = True    #真

a5 = False   #假

 

7、查看数据类型（type）

 1 >>> type(1) 
 2 <class 'int'> 
 3 >>> type(1.2) 
 4 <class 'float'> 
 5 >>> type(jixuege) 
 6 Traceback (most recent call last): 
 7   File "<stdin>", line 1, in <module> 
 8 NameError: name 'jixuege' is not defined
 9 
10 上面报错原因就是没有用双引号引起来，他就不是字符串，而是认为是一个变量。 
11 >>> type("jixuege") 
12 <class 'str'>

 

三、for和while循环

这里呢就需要涉及到break和continue的区别了。

如何理解呢？

break： 只能跳出当前循环，当前这一套循环就结束了。

continue： 跳出当次循环，然后呢还会去继续下一次别的循环。

 

for循环示例1：

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 for i in range(10):
6     print("loop",i)

执行结果：

 1 loop 0
 2 loop 1
 3 loop 2
 4 loop 3
 5 loop 4
 6 loop 5
 7 loop 6
 8 loop 7
 9 loop 8
10 loop 9

 原理图：

 

 for循环示例2：

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 for i in range(0,10,2):
6     print("loop",i)

执行结果：

1 loop 0
2 loop 2
3 loop 4
4 loop 6
5 loop 8

原理图：

 

for循环示例3：

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 for i in range(0,10,3):
6     print("loop",i)

执行结果：

1 loop 0
2 loop 3
3 loop 6
4 loop 9

 

for循环示例4：

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #Author: nulige
 4 
 5 age_of_oldboy = 56
 6 count = 0
 7 
 8 while count <3:
 9     guess_age = int(input("guess age:"))
10     if guess_age == age_of_oldboy :
11         print("yes, you got it. ")
12         break
13     elif guess_age > age_of_oldboy:
14         print("think smaller... ")
15     else:
16         print("think bigger!")
17     count +=1
18     if count == 3:
19         countine_confirm = input("do you want to keep guessing..?")
20         if countine_confirm != 'n':
21             count = 0
22 else:
23     print("you have tried too many times..fuck off")

执行结果：

输入三次数字，按回车就继续，按n 就退出。

 1 guess age:1
 2 think bigger!
 3 guess age:23
 4 think bigger!
 5 guess age:3
 6 think bigger!
 7 do you want to keep guessing..?
 8 guess age:1
 9 think bigger!
10 guess age:2
11 think bigger!
12 guess age:3
13 think bigger!
14 do you want to keep guessing..?n
15 you have tried too many times..fuck off

原理：

 

for循环示例5：

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #Author: nulige
 4 
 5 age_of_oldboy = 56
 6 for i in range(3):
 7     guess_age = int(input("guess age:"))
 8     if guess_age == age_of_oldboy :
 9         print("yes, you got it. ")
10         break
11     elif guess_age > age_of_oldboy:
12         print("think smaller... ")
13     else:
14         print("think bigger!")
15 else:
16     print("you have tried too many times..fuck off")

执行结果：

1 guess age:23
2 think bigger!
3 guess age:58
4 think smaller... 
5 guess age:56
6 yes, you got it.

原理图：

 

for循环示例6：

说明：打印五次hehe...

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #Author: nulige
 4 
 5 for i in range(0,10):
 6     if i <5:
 7         print("loop ",i)
 8     else:
 9         continue
10     print("hehe...")

执行结果：

 1 loop  0
 2 hehe...
 3 loop  1
 4 hehe...
 5 loop  2
 6 hehe...
 7 loop  3
 8 hehe...
 9 loop  4
10 hehe...

 

for循环示例7：

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4 
5 for i in range(10):
6     print('-------------',i)
7     for j in range(10):
8         print(j)

执行结果：

  1 ------------- 0
  2 0
  3 1
  4 2
  5 3
  6 4
  7 5
  8 6
  9 7
 10 8
 11 9
 12 ------------- 1
 13 0
 14 1
 15 2
 16 3
 17 4
 18 5
 19 6
 20 7
 21 8
 22 9
 23 ------------- 2
 24 0
 25 1
 26 2
 27 3
 28 4
 29 5
 30 6
 31 7
 32 8
 33 9
 34 ------------- 3
 35 0
 36 1
 37 2
 38 3
 39 4
 40 5
 41 6
 42 7
 43 8
 44 9
 45 ------------- 4
 46 0
 47 1
 48 2
 49 3
 50 4
 51 5
 52 6
 53 7
 54 8
 55 9
 56 ------------- 5
 57 0
 58 1
 59 2
 60 3
 61 4
 62 5
 63 6
 64 7
 65 8
 66 9
 67 ------------- 6
 68 0
 69 1
 70 2
 71 3
 72 4
 73 5
 74 6
 75 7
 76 8
 77 9
 78 ------------- 7
 79 0
 80 1
 81 2
 82 3
 83 4
 84 5
 85 6
 86 7
 87 8
 88 9
 89 ------------- 8
 90 0
 91 1
 92 2
 93 3
 94 4
 95 5
 96 6
 97 7
 98 8
 99 9
100 ------------- 9
101 0
102 1
103 2
104 3
105 4
106 5
107 6
108 7
109 8
110 9
111 
112 Process finished with exit code 0
View Code

 

 

 

 

PyCharm代码调试

 

break和continue的区别

示例1：

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #Author: nulige
 4 
 5 for i in range(10):
 6     print('-------------',i)
 7     for j in range(10):
 8         print(j)
 9         if j>5:
10             break

执行结果：

 1 ------------- 0
 2 0
 3 1
 4 2
 5 3
 6 4
 7 5
 8 6
 9 ------------- 1
10 0
11 1
12 2
13 3
14 4
15 5
16 6
17 ------------- 2
18 0
19 1
20 2
21 3
22 4
23 5
24 6
25 ------------- 3
26 0
27 1
28 2
29 3
30 4
31 5
32 6
33 ------------- 4
34 0
35 1
36 2
37 3
38 4
39 5
40 6
41 ------------- 5
42 0
43 1
44 2
45 3
46 4
47 5
48 6
49 ------------- 6
50 0
51 1
52 2
53 3
54 4
55 5
56 6
57 ------------- 7
58 0
59 1
60 2
61 3
62 4
63 5
64 6
65 ------------- 8
66 0
67 1
68 2
69 3
70 4
71 5
72 6
73 ------------- 9
74 0
75 1
76 2
77 3
78 4
79 5
80 6
View Code

 

 

示例2:

 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 #Author: nulige
 4 
 5 
 6 for n in range(4):
 7     print(n)
 8     for j in range(3):
 9         if  j <2:
10         #如果j小于2就跳出当次循环，继续一下次循环
11             continue
12         print(n,j)

 

执行结果：

0 2
1 2
2 2
3 2

 

说明：

在第二次的if判断中，我执行条件，如果j小于2就跳出当次循环，继续一下次循环

下面我们就看看break的使用

同样的代码，咋们接着看

 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 #Author: nulige
 4 
 5 
 6 for n in range(4):
 7     print(n)
 8     break
 9     for j in range(3):
10         if  j <2:
11         #如果j小于2就跳出当次循环，继续一下次循环
12             continue
13         print(n,j)

执行结果：

0

小结：二者的区别，continue用于有很多次循环，然后呢，我不希望哪次循环执行下面的动作，就可以了使用continue ，而break呢就是我这次循环了以后我想跳出去不在循环，或者我写了一段代码，我想跳出去看看代码是否能执行，就可以用break。

 

作业一：编写登录接口

  • 输入用户名密码
  • 认证成功后显示欢迎信息
  • 输错三次后锁定

 

流程图

实现代码

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #Author: nulige
 4 
 5 
 6 count = 0
 7 while count < 3:
 8     login = '''
 9 Hello welcome to login Cnlogs!
10     '''
11     login2 = '''
12 Try again
13     '''
14     if count == 0:
15         print(login)
16     else:
17         print(login2)
18     user = input("please input your name:")
19     password = input("please input your password:")
20     accept = str(user + password)
21     for line in open("C:\\Users\\Administrator\\Desktop\\file.txt"):
22         line = line.strip("\n")
23         if accept == line:
24             print("Welcome to login Cnlogs",user)
25             exit()
26             break
27         else:
28             continue
29     print("Your password or username is wrong")
30     count +=1
31     if  count == 3:
32         print("fuck off")

file文件路径
file文件路径：C:\\Users\\Administrator\\Desktop\\file.txt"
file文件内容
1 nulige123456
2 alex123456
3 
4 #说明（把输入的用户名和密码，拼接为一个字符串。）
5 #username:nulige
6 #password:123456

执行结果：

说明：输入正确用户名和密码。比对正确，显示欢迎信息。

1 Hello welcome to login Cnlogs!
2     
3 please input your name:nulige
4 please input your password:123456
5 Welcome to login Cnlogs nulige

 

说明：输入三次错误的用户名和密码，第三次还错误就锁定。

 1 Hello welcome to login Cnlogs!
 2     
 3 please input your name:huzhihua
 4 please input your password:11111
 5 Your password or username is wrong
 6 
 7 Try again
 8     
 9 please input your name:skfjdskfjdsk
10 please input your password:321321
11 Your password or username is wrong
12 
13 Try again
14     
15 please input your name:fdskfjsk
16 please input your password:3333
17 Your password or username is wrong
18 fuck off

 

三、思路和遇到的坑。

1、把正确的用户名密码，存放在一个文本文件中。

2、用户名与密码，是两个独立的字符串，存放的时候把它俩加在一起，变成了“用户名密码”。

3、获取输入的用户名密码后，同样把用户名与密码拼接为“用户名密码”，来与文件中记录的用户名密码进行逐行对比。

4、坑！记录的文件中有换行符\n，也就是说“用户名密码\n”，但是输入的却没有“用户名密码”，导致字符串效验总是失败。

5、通过strip("\n")来去掉换行符。

 

补充知识

文章来源：http://www.cnblogs.com/zdz8207/p/python_learn_note_20.html

python strip()函数 去空格\n\r\t函数的用法

在Python中字符串处理函数里有三个去空格（包括'\n', '\r', '\t', ' ')的函数：

strip 同时去掉左右两边的空格
lstrip 去掉左边的空格
rstrip 去掉右边的空格

 

具体示例如下：
>>>a=" gho stwwl "
>>>a.lstrip() 'gho stwwl '
>>>a.rstrip() ' gho stwwl'
>>>a.strip() 'gho stwwl'

声明：s为字符串，rm为要删除的字符序列
s.strip(rm) 删除s字符串中开头、结尾处，位于 rm删除序列的字符
s.lstrip(rm) 删除s字符串中开头处，位于 rm删除序列的字符
s.rstrip(rm) 删除s字符串中结尾处，位于 rm删除序列的字符

 

注意：
1. 当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')

>>> a = ' 123'
>>> a.strip()
'123'
>>> a='\t\tabc'
'abc'
>>> a = 'sdff\r\n'
>>> a.strip()
'sdff'

 

2.这里的rm删除序列是只要边（开头或结尾）上的字符在删除序列内，就删除掉。

>>> a = '123abc'
>>> a.strip('21')
'3abc' 结果是一样的
>>> a.strip('12')
'3abc'

 

作业二：多级菜单

  • 三级菜单
  • 可依次选择进入各子菜单
  • 所需新知识点：列表，字典

 此处来源：金角大王写的青年文艺版（后期再补交）

 1 menu = {
 2     '北京':{
 3         '海淀':{
 4             '五道口':{
 5                 'soho':{},
 6                 '网易':{},
 7                 'google':{}
 8             },
 9             '中关村':{
10                 '爱奇艺':{},
11                 '汽车之家':{},
12                 'youku':{},
13             },
14             '上地':{
15                 '百度':{},
16             },
17         },
18         '昌平':{
19             '沙河':{
20                 '老男孩':{},
21                 '北航':{},
22             },
23             '天通苑':{},
24             '回龙观':{},
25         },
26         '朝阳':{},
27         '东城':{},
28     },
29     '上海':{
30         '闵行':{
31             "人民广场":{
32                 '炸鸡店':{}
33             }
34         },
35         '闸北':{
36             '火车战':{
37                 '携程':{}
38             }
39         },
40         '浦东':{},
41     },
42     '山东':{},
43 }
44 
45 
46 exit_flag = False
47 current_layer = menu
48 
49 layers = [menu]
50 
51 while not  exit_flag:
52     for k in current_layer:
53         print(k)
54     choice = input(">>:").strip()
55     if choice == "b":
56         current_layer = layers[-1]
57         #print("change to laster", current_layer)
58         layers.pop()
59     elif choice not  in current_layer:continue
60     else:
61         layers.append(current_layer)
62         current_layer = current_layer[choice]

 

posted @ 2016-11-02 16:10  努力哥  阅读(2484)  评论(0)  编辑  收藏  举报