python基础之2

1.模块
sys模块
注意：python文件的文件名一定不能和下面的要导入的模块同名，如：sys_mokuai.py

windows下的python3里直接运行：
import sys    ------------ 导入系统中的sys模块
print(sys.path)   ------------- 打印环境变量，------>模块的使用方法：模块名称.具体某型功能名称
执行结果---->
C:\Users\Administrator\AppData\Local\Programs\Python\Python36\python.exe I:/pathon合集/python工作目录/string_valiable.py
['I:\\pathon合集\\python工作目录', 'I:\\pathon合集\\python工作目录', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\python36.zip', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\DLLs', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\lib', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\lib\\site-packages']
进程已结束,退出代码0

在pycharm里也是这样的,运行结果和上面的一样的。
#_*_coding:utf-8_*_
# Author:chen
import sys
print(sys.path)

---> 'E:\\PycharmProjects\\pyday1', 此时，运行这个程序后，系统会到这些Python的环境变量中去找，当所有的路径里都没有时，会报错
....... 若存在，就加载该模块进来
.......

一般第三发库的默认安装位置：E:\python\base\lib\site-packages
   标准库的.......... .... E:\python\base\lib

分类：

标准库：不需要安装，可以直接导入就可以使用的库。比如：sys模块和os模块
第三方：必需下载，安装后才可以使用的库，比如：zhanggou

自定义模块：自己编写的.py结尾的文件

2,添加默认的 utf-8 编码

当看到关于 ASCII 编码的错误，那就在你的python 脚本的最上面加入这一行：
# _*_ coding: utf-8 _*_
这样你就在脚本中使用了 unicode UTF-8 编码，这些错误就不会出现了。

使用 # 在代码每一行的前一行为自己写一个注解，说明一下这一行的作用。

3,变量可以加减

例1：

a = 4
b = 5
c = 10
print('a/c =',a/c)

例2：

my_name = 'Zed A. Shaw'
my_age = 35 #not a lie
my_weight = 74 #inches
my_height = 184 #lbs
my_eyes = 'blue'
my_teeth ='white'
my_hair = 'brown'

print('let is talk about %s.'%my_name )
print('He is %d inches tall.'%my_weight) ------------------ 用%s也可以，整个程序中都用%s都可以。
print('He is %d pounds heavy.'%my_height)
print('Actually that is not too heavy.')
print('He is got %s eyes and %s hair.'%(my_eyes,my_hair))
print('His teeth are usually %s depending on the coffee.'%my_teeth)
#this line is tricky,try to get it exactly right
print('If I add %d,%d, and %d I get %d.'%(my_age,my_height,my_weight,my_age + my_height + my_weight)) #变量可以直接算术运算，运算符前后有空格

4，变量的多重引用(变量可以引用变量)
4.1 多个变量的直接调用
x = 'There are %d types of people.'% 10    ---------------> 此处的%前后有没有空格都不影响。都可以成功。
binary = 'binary'       #binary:二进制的。双重的，由两个东西组成的
do_not = "don't"
y = 'Those who know %s and those who %s.' %(binary,do_not)
print(x)
print(y)
print('I said: %r.'%x)     #变量必需在括号内，即括号内的内容代表打印的内容。括号外就不属于print的范围了
print('I said also:"%s".'%y)

4.2 把变量当成参数，调用时再导入
hilarious = False
joke_evaluation = "Isn't that joke so funny?! %r"    -----------> 此处不传参数，等到调用时再传参数。也可以。

print(joke_evaluation % hilarious)     ------------> 调用时再传参数(%前后有无空格都可以），传入的参数是定值也可以（%'sfaf'），是变量也可以(%xxx)

4.3 变量的叠加
w = 'This is the left side of ...'
e = 'a string with a right side.'

变量的叠加形式：
print (w + e)  --------> This is the left side of ...a string with a right side.
print (w，e)  --------> This is the left side of ... a string with a right side.
注意：采用 w + e这种方式：是将w和e连接起来，所以他们之间没有空格，即前后衔接的两个字符串后合并成一个字符串
采用传统的w,e这种方式，会将两个字符串都在一行显示，同时为了暗示是两个字符串，所以他们之间有一个空格，以便于区分这是两个变量。

5，脚本里传入参数 （Linux命令行里演示）

[root@nginx1 python]# cat 5.py
import sys

print(argv)
print(sys.argv[2])     # ------ 打印传入参数的第二个参数

执行：

[root@nginx1 python]# python 5.py 1 2 3
['sys_mod.py',1,2,3]   --------- 识别参数从0号开始，一次为0,1,2,3这样的
2    ---------（第2号参数，第三个参数）

6,os模块

Linux里面演示：

[root@nginx1 python]# ls
2.py 3.py 4.py 5.py 6.py 7.py a.py

[root@nginx1 python]# cat 6.py
import os
os.system('dir')

[root@nginx1 python]# python 6.py
2.py 3.py 4.py 5.py 6.py 7.py a.py
[root@nginx1 python]# vim 6.py

[root@nginx1 python]# cat 6.py
import os
print(os.system('dir'))

[root@nginx1 python]# python 6.py
2.py 3.py 4.py 5.py 6.py 7.py a.py
0            -------------------------------------------------     print打印一个os.system('dir')运行后的退出码。

Windows下python软件里运行：
import os
os.system('dir') ------------执行后打印当前路径下目录。会出现乱码，正常的。因为Windows默认输出不是UTF-8。
该命令在cmd的命令行里就不会报错，显示出的也不会有乱码。

驱动器 C 中的卷没有标签。
卷的序列号是 A2A7-A8AC
C:\Users\Administrator\AppData\Local\Programs\Python\Python36 的目
2017/08/10 周四 上午 08:27 <DIR> .
2017/08/10 周四 上午 08:27 <DIR> ..
2017/08/10 周四 上午 08:26 <DIR> DLLs
2017/08/10 周四 上午 08:26 <DIR> Doc
2017/08/10 周四 上午 08:26 <DIR> include
2017/08/10 周四 上午 08:26 <DIR> Lib
2017/08/10 周四 上午 08:26 <DIR> libs
2017/03/21 周二 下午 06:47 30,351 LICENSE.txt
2017/03/21 周二 下午 05:48 334,939 NEWS.txt
2017/03/21 周二 下午 06:44 100,504 python.exe
2017/03/21 周二 下午 06:42 58,008 python3.dll
2017/03/21 周二 下午 06:42 3,562,648 python36.dll
2017/03/21 周二 下午 06:44 98,968 pythonw.exe
2017/08/10 周四 上午 08:27 <DIR> Scripts
2017/08/10 周四 上午 08:26 <DIR> tcl
2017/08/10 周四 上午 08:26 <DIR> Tools
2016/06/09 周四 下午 10:53 87,888 vcruntime140.dll
7 个文件 4,273,306 字节
10 个目录 61,677,092,864 可用字节
0

在pycharm中运行可以成功，但有乱码。
import os
cmd_res = os.system('dir')    ---------> 将这个模块的这个功能来给变量赋值，调用windows里的命令：dir，若为Linux系统就用ls
print(cmd_res)
在pycharm里会有未识别的字符。在
?????? I ?е???? ???
??????к??? 0005-E127

I:\pathon???\python?????? ????

2017/09/04 ??? ???? 11:37 <DIR> .
2017/09/04 ??? ???? 11:37 <DIR> ..
2017/09/04 ??? ???? 11:36 <DIR> .idea
2017/09/04 ??? ???? 11:37 69 1.py
2017/09/04 ??? ???? 09:00 0 2.py
2 ????? 69 ???
3 ???? 164,514,689,024 ???????

进程已结束,退出代码0

注意：实际情况是：
os这个命令，你一旦调用，他就执行，但他的结果只输出到屏幕，不会输出给变量。

import os
cmd_res = os.system('dir')
cmd_res = os.popen('dir')
print ('--->',cmd_res)

?????? I ?е???? ???
??????к??? 0005-E127

I:\pathon???\python?????? ????

2017/08/15 ??? ???? 09:52 <DIR> .
2017/08/15 ??? ???? 09:52 <DIR> ..
2017/08/15 ??? ???? 09:29 <DIR> .idea
2017/08/15 ??? ???? 01:45 220 3.py
2017/08/15 ??? ???? 02:16 342 4.py
2017/08/14 ??? ???? 09:02 226 input.py
2017/08/15 ??? ???? 03:06 602 more_variable.py
2017/08/15 ??? ???? 08:54 188 print.py
2017/08/15 ??? ???? 09:52 92 string_valiable.py
2017/08/15 ??? ???? 02:40 594 variable.py
7 ????? 2,264 ???
3 ???? 177,133,514,752 ??????? -------------------------上面的这么多都是print os.system('dir')的结果
---> <os._wrap_close object at 0x0000000001E8E780> --------------------print os.popen('dir')的结果，内存的对象地址

进程已结束,退出代码0

........................................................................................................................

pycharm中运行：将结果从内存里读出来：

import os
cmd_res = os.system("dir") ----------------------显示出了的有乱码
cmd_res = os.popen('dir').read()
print ('--->',cmd_res) ---------------------------显示出的是正确的代码，无乱码

运行结果如下：

?????? I ?е???? ???
??????к??? 0005-E127

I:\pathon???\python?????? ????

2017/08/15 ??? ???? 09:56 <DIR> .
2017/08/15 ??? ???? 09:56 <DIR> ..
2017/08/15 ??? ???? 09:54 <DIR> .idea
2017/08/15 ??? ???? 01:45 220 3.py
2017/08/15 ??? ???? 02:16 342 4.py
2017/08/14 ??? ???? 09:02 226 input.py
2017/08/15 ??? ???? 03:06 602 more_variable.py
2017/08/15 ??? ???? 08:54 188 print.py
2017/08/15 ??? ???? 09:56 99 string_valiable.py
2017/08/15 ??? ???? 02:40 594 variable.py
7 ????? 2,271 ???
3 ???? 177,133,514,752 ???????
---> 驱动器 I 中的卷是 软件
卷的序列号是 0005-E127

I:\pathon合集\python工作目录 的目录

2017/08/15 周二 下午 09:56 <DIR> .
2017/08/15 周二 下午 09:56 <DIR> ..
2017/08/15 周二 下午 09:54 <DIR> .idea
2017/08/15 周二 下午 01:45 220 3.py
2017/08/15 周二 下午 02:16 342 4.py
2017/08/14 周一 下午 09:02 226 input.py
2017/08/15 周二 下午 03:06 602 more_variable.py
2017/08/15 周二 上午 08:54 188 print.py
2017/08/15 周二 下午 09:56 99 string_valiable.py
2017/08/15 周二 下午 02:40 594 variable.py
7 个文件 2,271 字节
3 个目录 177,133,514,752 可用字节

进程已结束,退出代码0

..................................................
补：os模块在当前路径下创建一个目录：

import os
os.mkdir('new_dir')   ------->运行后在pycharm 的左边菜单里可以看到会多出的一个新建的目录

7.自定义模块的调用，注意，模块名尽量不用中文

7.1，先写一个自定义的模块：login.py
_username = 'alex'
_password = '123'
user = input("请输入用户名：")
pwd = input("请输入密码：")
if user = _username and pwd = _password:
print ("WELCOME USER %s login"% user)
else:
print("wrong username or password")
print(user,pwd)

7.2 ,调用方法：a.py

import login.py   -------------> 首先会在当前路径下找login.py这个模块，当没有时，会到Python的环境变量里去找。找到就执行
执行就行了，正常库的位置为：C:\python\base\lib\site-package\,若在这两个地方都找不到，就会报错。

8 .pyc是什么文件
计算机不能识别高级语言，当我们运行一个高级语言时，就需要“编译”或者“解释”，
编译语言：在程序执行之前就编译，直接执行就行了。例如c语言，快，效率高，
解释语言：在程序运行时，逐步进行解释，然后运行，例如：Ruby 和python

JAVA 是一种先编译后解释的语言。执行过程：
1，javac hello.java ----进行 预编译，完成后也不是机器语言，也是一个半成品
2，Java hello ----

执行python hello.py，第一项工作是编译，然后才是激活了python的解释器，告诉解释器，你要开始工作了，python其实也是一门先编译后解释的语言
PycodeObject 就是Python编译器真正编译成的结果。python程序运行时，编译的结果保存在内存中的PyCodeObject中。当运行结束时，解释器则把PYCodeobjiect写回到pyc文件中，当python程序第二次运行时，首先程序会到硬盘中寻找pyc文件，如果找到，直接载入，否则就重复上面的操作。
所以：pyc是PyCodeObject的一种永久化的保存方式
注意：python的会自带检查pyc。当你更新了某个程序的元代码，运行时，python会自动检查更新时间，当发现不一致时，会重新运行，重新生成pyc文件，pyc就是半成品吧，不是机器码，大概百分之15左右，

9,python的比较大小运算

python可以判断大小，返回布尔值，真就返回True,假就返回False，可以直接进行加减乘除运算。直接返回运算结果。运算符号前后是否加空格都不影响。

print('Is it greater?', 5 > -2)
print ('Is it greate?','5 > -2')
print('Is it less or equal',5 <= 2)
------->

Is it greater? True
Is it less or equal False

进程已结束,退出代码0

print(5+6+6+4)
print(5 + 45465 +5454545+6564)    ---------> 进行数据自动运算，数值前后不用加空格也可以
print(5*6352/564+5487+63541-5645)
------------>
21
5506579
63439.31205673759

进程已结束,退出代码0

10、字符串相加：直接前后衔接。
w = 'sa af a asf afasf'
e = 'aaaaaaaaa aaaaaaaaaaaaaaa'
print (w + e)

-------->
sa af a asf afasfaaaaaaaaa aaaaaaaaaaaaaaa

11,数据类型

11.1 int：数字、整数形式, int 在32位系统里：取值范围：-2**31 ~ 2**31-1 大概42亿多
                                在64位系统里：取值范围：-2**63 ~ 2**63-1
长整形，long 理论上可以无限长，在python3里好像没有了
验证：type（2**100）--运行下
浮点型，float 带有小数的实数
复数型，complex 由实数和虚数组成，一般形式：x + yi , -5 + 4j 这里的5和4为实数，j为虚数

补：52.3E-4 = 52.3 * 10**4 =523000

11.2 布尔值：

1 真 -------- True
0 假 -------- False

11.3 字符串：
Bytes类型：字节数据类型，二进制的数据类型，不同于字符串。---和字符串相互转换
msg = "我爱北京天安门"
print（msg）
print（msg.encode()）---------->默认就用utf-8,进行编码后打印出来
再转回来：
print（msg.encode().decode()） ---------> 先安装默认设置编码，再解码，又成为原来的这样了

str ---->bytes:encode bytes ------> str :decode

12, 三元运算
result = 值1 if 条件 else 值2

例：

a,b,c = 995,145,5    -------->   一次性给三个变量赋值
d =a if a >b else c
print(d)   ---->如果a大于b，那d的值就是a，如果a不大于b,那d的值就是c , 此处d的值应为995。
简化了表达式：

if a >b:d=a
else:d=c

13,进制
二进制：0 1
八进制：0 1 2 3 4 5 6 7
十进制：0 1 2 3 4 5 6 7 8 9
十六进制：0 1 2 3 4 5 6 7 8 9 A B C D E F

注意：16进制，用H做后缀或者0X做前缀，例如：BH --->12(十六进制的)
0X23 --->(十六进制的)23

14,列表

14.1,列表取值：切片
例：

name = ['zhang','hehee','guxian','hejk']
print(name)
print(name[0]) --->print(name[0],name[2])
print(name[1:3]) ----->切片：取从1开始的到3结束（不包括3）的连续的值，又叫：顾头不顾尾
print(name[-1]) ----->取最后一个位置，倒数第二个位置：[-2]
print(name[-3:-1]) ---->取出倒数第三个数，倒数第二个数
print（name[-2:]）------>取出倒数两个数，不管怎么取，切片取值的都是从左往右取
print(name[0:3]) == print(name[:3])

14.2，列表追加值：
末尾追加：
names = ['a','b','c','d','e','f']
names.append('xxx')
print(names)

中间追加:(插入后是什么位置就用什么数字)
names = ['a','b','c','d','e','f']
names.insert(1,'yyy') --------------- 这里的1这个位置：就是列表中的1的位置，按照顺序数是第二个。

改某个值
names = ['a','b','c','d','e','f']
names[2] = 'xxx'
print(names) --->a xxx b c d e f

删除某个值
names = ['a','b','c','d','e','f']
names.remove('b') --------方法1
names.pop(1) ---------方法2，指定删除列表中顺序号为1的元素，不写下标，默认删除最后一个
del names[1] ---------方法3，指定删除列表中顺序号为1的元素。

查询某个值在什么位置（以数字显示的）：
names = ['a','b','c','d','e','f']
print（names.index('c')） ------->2
print( names[names.index('c')] ) ---->c

统计列表中某个值的个数：
names = ['a','b','c','d','e','f','d']
print(names.count('d')) ------->2

清空列表内容：clear
names = ['a','b','c','d','e','f']
print(names)
names.clear()
print(names) ----------> []

反转列表：reverse
names = ['a','b','c','d','e','f']
print(names)
names.reverse()
print(names)

排序：sort 按照ASCII码里的规则来的，特殊字符最前面--》 数字 ---》大写字母 ---》小写字母
names = ['42a','Ab','Ac','d','#e','f']
print(names)
names.sort()
print(names)

加入别的列表：extend
names = ['a','b','c','d','e','f']
names2 = [1,2,3,4]
names.extend(names2) ---------> 在a的列表末尾再加上b的列表，会变成新的重新生成后的列表。
print(names,names2) -->[a,b,c,d,e,f,g,1,2,3,4] [1,2,3,4]

注意：extend与append的区别：append追加一次只追加一个元素（也可以将整个列表当成一个元素追加进去了），而extend是追加整个列表,将列表里的每一个元素都作为新元素追加到原列表中去。
names=['a','b','c','d','e','f','g']
names2=[1,2,3,4,5,6,7,8,9]
names.append(names2)
print(names)
执行后的情况如下：
['a', 'b', 'c', 'd', 'e', 'f', 'g', [1, 2, 3, 4, 5, 6, 7, 8, 9]]

删除变量：del
names = ['a','b','c','d','e','f']
names2 = [1,2,3,4]
del names2
print(names,names2) ---------->此时会报错，因为names2已经被删除掉了。

复制列表：copy
names = ['a','b','c','d','e','f']
name2 = names.copy()
print(names)
print(name2)
总结：清空列表用：name.clear(),列表删除用del name

names = ['a','b','c','d','e','f']
name2 = names.copy()
print(names)
print(name2)
names['2'] = '和'
print(names) -----会改
print(name2) -----不变

补充：列表中可以再添加子列表：
names =[1,2,3,4,5,['a','b','c','d','e','f']6,7,8,9]
print（names） ————》[1,2,3,4,5,['a','b','c','d','e','f']6,7,8,9] 子列表仍然被当成一个元素来处理
调取子列表的第1个元素的值：print（names[5][0]）
将 子列表的第1个元素的值改为fuck：names[5][0] = 'fuck'

names =[1,2,3,4,5,['a','b','c','d','e','f']6,7,8,9]
name2 = names.copy()
print(names)
print(name2)
names[3] = 'FUCK'
names[5][0] = 'fuck' ------------- 注意：此时的写法仅限于列表中包含了子列表时的情况，因为子列表第6号位置，故第一个位置为[5],子列表里面的位置也是按照从0号开始的原则进行排列
print(names)
print(name2) ---------------此时的原列表不变，而子列表里的内容会改变。
解释：copy：浅copy，只复制了第一层，即第一层的不变，对里面的第二层的子列表。则copy不到，即一旦发生改变，则变量立即跟着改变

15,copy的三种方式：结果都一样。
person = ['name',['a',100]]
p1=person.copy()   # 直接复制
p2=person[:] --------- 无开头和无结尾，即全部copy
p3=list(person)

例：

person = ['name',['save-money',100]]
p1=person[:]
p2=person[:]
p1[0]='alex'
p2[0]='fengjie'
print(p1)
print(p2)

p1[1][1]=50
print(p1) -------->联合账号，一个变，其他的账号跟着变。
print(p2)

.................................................................................................................................................

16,元组：tuple

就是列表，跟列表一样，不同之处：元组不能增删改，一旦创建，永远就是这样。又叫只读列表，只能查。
元组的写法也由中括号降为小括号了，即小括号即为元组。
names = ('aaa','bbb','ccc')

只有两个方法：count 和index。
print(names.count('bbb')) ------>获取下标
print(names.index('ccc')) ------>获取下标
注意：当原先的元组n = ('0122',2,3,4,5,6,'098',7,8,9,99,9897)时，
print(n.index(9897))，此时的9897不能加引号，若加了会报错。因为此时默认当成数字类型，加了引号就当成了字符串类型的。所以会报错。

17,购物车程序实例：
product_list = [('iphone',5800),('mco',9800),('bike',800),('watch',10600),('coffee',31),('alex python',120)]
salary = input('Input you salary:') -------此时输入的是字符串类型的
shopping_list = []
if salary.isdigit(): ----- 如果是1 或者2等通过isdigit判断后就是真，即本质为数字，但为字符串的形式
salary = int(salary)
while True:
for item in product_list:
print(product_list.index(item),item) -------------打印商品列表
user_choice = input('wath do you want to buy: ') ------- 让用户选择买什么东西
if user_choice.isdigit(): --------判断用户输入的必需是数字类型
user_choice = int(user_choice)
if user_choice < len(product_list) and user_choice >-1:
p_item = product_list[user_choice] -------------通过下标包商品取出来
if p_item[1] <= salary: #买得起
shopping_list.append(p_item)
salary -= [p_item[1]
print('Added %s into shopping cart,you current balance is %s' %(p_item,salary)) #红色：31，绿色32，%s改为：\033[31;1m%s\033[0m
else:
print('\033[41;1m你的余额只剩[%s]'，买不了了\033[0m % salary) #31为红色，41为背景红色，32为绿色，42为背景为绿色
else:
print('product code [%s] is not exist!'% user_choice)
elif user_choice == 'q':
print('-------------- shopping list------------')
for p in shopping_list:
print(p)
print('you current balance:',salary)
exit()
else:
print('invalid option')

.......................................................................................................................................................................

18，字符串的操作

name = 'alex'
print(name.capitalize()) ------- 首字母大写
print（name.count('a')） ------- 统计有几个字符“a”

print(name.center('50','-')) ----- 一共打印50个字符。不够的就两边用‘-’补上，注意：50上面不能加‘’，改成：print（name.center(50,'_'）)
print(name.ljust(50,'=')) ------ 一共打印50个字符，若不够在末尾用'='补上
print(name.rjust(50,'=')) ------ ..........................前面.........

print(name.encode()) ------------ 将字符串转成二进制
print(name.endwith('ex')) ----------判断字符串是否以‘ex’结尾，判断邮件地址是否以.com结尾
print(name.find('e')) ----------字符串也可以切片,每个字符作为一个单位来切，作用同列表，命名顺序：0,1,2 ...

字符串里有变量的处理：
name = "my \t name is {name} and i am {year} old"
* print(name.format(name='alex',year=33)) ---------format :格式转换后传参数进去
--->
my name is alex and i am 23 old

* print(name.format_map({'name':'alex','year':'12'})) ---------字典用法（很少用，只用format就可以了）
---->
my name is alex and i am 12 old
* print(name.index()) ---------- 打印下标
* print（name.isalnum()） -------- 判断是不是：阿拉伯数字 + 阿拉伯字符(所有的英文字符加1到9)，特殊字符就不是，[比如直接判断：print('ab123'.isalnum()) ---> True ]
————>
False （或者：True）

print('ab33'.isalpha()) ------- 是否为纯英文字符，返回值为True或者False
print('adf'.isdecimal()) -------- 是否为十进制数字， .....................用处不大。用不到

print('adb'.isdigit()) ------ 判断是否为正整数
print('adfa'.isidentifier()) ------ 用得少，标识符，判断是不是一个合法的标识符即‘是不是一个合法的变量名。’

print('adfs'.islower()) ------ 判断是否为小写
print('adf'.isupper()) ------- 是否为大写
print('ADFdfs'.lower()) ---------将字符串中的大写变成小写
print('afasf'.upper()) -----变成大写
print('Alie li'.swapcase()) -------------大小写全部相互转换

print('afad.isnumeric()) --------是否为数字，整数就返回True,小数和字母就返回False,和isdigit作用相同，用处不大
print(' '.isspace()) ----- 是否为空格，
print('af'.istitle()) ------- 字符串里的每个单词的首字母是否为大写，返回值：True 和False

print('' '+'.join(['1','2','3','4']))
-----> 1+2+3
将数组连在一起打印出来，经常用到。

print('afdf\n'.rstrip()) 去掉字符串右边的空格和回车
print('\ndfaf'.lstrip()) ...........左。。。。。。。
print(' afasf\n'.strip()) 去掉字符串中所有的空格和回车

字符串里的字母转换
p = str.maketrans('abcde','12345') -----------------> 定义转换的规则
print('alex li'.translate(p)) ------------------> 引用上面定义好的转换规则并打印出来
---->
1l5x li

name = 'my name is name,and i am year old'
p = str.maketrans('abcde','12345')
print(name.translate(p))
执行结果如下：
my n1m5 is n1m5,1n4 i 1m y51r ol4

单个字母的替换
print('alex'.replace('l','L')) ---------------->注意：中间的标点符号为. 而不是，
print('alex li'.replace('l','L',1)) --------------->仅替换第一个L字母，不指定就是所有的L字母都替换

查找单个字母的位置
print('alex li'.rfind('e')) ---> 3 找到最后一个这个字母的小标并返回

将字符串按照按照空格分割成列表：
print('alex lile'.split()) -----> ['alex','lile']
按照指定的字母分：
print('alex li'.split('l')) -----> ['a','ex','i']
按照换行符来分：
print('1+2\n+3+4'.splitlines()) -----> ['1+2','3+4']------------完全可以用.split('\n')来代替

19，enumerate用法，打印角标和元素

a=['a','b','c','d']
for i in enumerate(a):
    print(i)

---------->
(, 'a')
(, 'b')
(, 'c')
(, 'd')

即顺带将列表里的角标也打印出来了。

列表和字典及几何是最长用的

20，字典

用大括号表示，字典是一种key-value的数据类型,特点：dict是无序的，因为字典是没有下标的。字典通过key去找值，所以不需要下标。

增删改查操作：

info = {
     'stu001':'aaa'，  # ------------------ 注意：每个值的后面有逗号，分割！！！！！！
     'stu002':'bbb'，
     'stu003':'ccc'， # -------->最后一个元素的逗号可以不写。
}

查询：

print(info) ----> [ 'stu001':'aaa'，'stu002':'bbb'，'stu003':'ccc'] ----------注意，这个不一定是按照先后顺序显示的，完全是随机的顺序显示
print(info['stu001']) ----> aaa

修改

info['stu001'] =''    #  确保字典里有这个值就用这个方法。否则不要用这个方法，若没有会报语法错，exit code 1
print(info) ----> [ 'stu001':''，'stu002':'bbb'，'stu003':'ccc']
print(info.get('stu007'))   # 若没有则提示：None ，同时exit code 0

增加
向字典里添加一条健值，就是直接定义健值就可以了:

info['stu005'] =''   # --------- 添加一个健值和修改一个健值的命令相同，如果这个key存在，就修改对应的值，若不存在就是创建这个值。
print(info) 

--->
['stu005':'',stu001':'aaa'，'stu002':'bbb'，'stu003':'ccc']

删除

del info['stu001']
print(info)
info.pop('stu001') ---- 和del info的作用相同
del info ----> 删除整个字典

判断字典里有没有某个键或者元素

print('stu003' in info)

打印所有的值：

info.vallues()

打印所有的key

info.key

实例：多级字典的嵌套及操作

data = {
    '北京': {
        "昌平": {
            "沙河": ["oldboy", "test"],
            "天通苑": ["链家地产", "我爱我家"]
        },
        "朝阳": {
            "望京": ["奔驰", "陌陌"],
            "国贸": {"CICC", "HP"},
            "东直门": {"Advent", "飞信"},
        },
        "海淀": {},
    },
    '山东': {
        "德州": {},
        "青岛": {},
        "济南": {}
    },
    '广东': {
        "东莞": {},
        "常熟": {},
        "佛山": {},
    },
}
exit_flag = False

while not exit_flag:
    for i in data:
        print(i)
        choice = input("选择进入1>>:")
        if choice in data:
            while not exit_flag:
                for i2 in data[choice]:
                    print("\t", i2)
        choice2 = input("选择进入2>>:")
        if choice2 in data[choice]:
            while not exit_flag:
                for i3 in data[choice][choice2]:
                    print("\t\t", i3)
        choice3 = input("选择进入3>>:")
        if choice3 in data[choice][choice2]:
            for i4 in data[choice][choice2][choice3]:
                print("\t\t", i4)
        choice4 = input("最后一层，按b返回>>:")
        if choice4 == "b":
            pass
        elif choice4 == "q":
            exit_flag = True
        if choice3 == "b":
            break
        elif choice3 == "q":
            exit_flag = True
        if choice2 == "b":
            break
        elif choice2 == "q":
            exit_flag = True