Python 第二课笔记

本节内容

1. 模块初识
2. pyc
3. 数据类型-数字，布尔值，字符串，bytes
4. 列表、元组操作
5. 深浅copy
6. 字符串操作
7. 字典操作
8. 三元运算
9. 进制

1、模块初识

Python标准库和第三方库，

写好的功能封装好，起个名字，就是模块也叫库，直接导入就能用了。

标准库就是不需要安装，就能够导入的库

第三方库必须下载，安装才能使用的库。

1.1 两个标准库，sys模块和os模块

sys模块

******创建的项目文件名字不能与导入的库名相同*******

 import sys   #带入sys模块

 print(sys.path)  #调用sys模块的方法，sys.方法名

【运行结果】

['D:\\Python\\s014\\DAY2', 'D:\\Python\\s014', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python35\\python35.zip', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python35\\DLLs', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python35\\lib', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python35', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python35\\lib\\site-packages']

*************输出的全局的环境变量***************

要导入的模块必须要在以下目录的一个里面，如果不存在，就说这个模块没找到，如果存在直接加载成功！

******Python35\\lib\\site-packages***第三方库一般都存在这里

********标准库存放在Python35\\lib\\ 目录下*************

 import sys   #带入sys模块

 print(sys.argv)

【运行结果】打印绝对路径

['D:/Python/s014/DAY2/sys_import.py']

os模块

dir查看当前目录下的文件

 import os

 os.system("dir")

运行结果

  ������ D �еľ��� �¼Ӿ�
  �������� CE45-B8E3

  D:\Python\s014\DAY2 ��Ŀ¼

 2017/01/08  18:39    <DIR>          .
 2017/01/08  18:39    <DIR>          ..
 2017/01/08  18:39               270 sys_import.py
                1 ���ļ�            270 �ֽ�
                2 ��Ŀ¼ 37,835,636,736 �����ֽ�

windows编码与UTF-8不一致导致的乱码，不用管

将命令存在一个变量里打印

 import os

 cmd_comand=os.system("dir")#执行命令不保存结果
 print("********>>>>>",cmd_comand)

 ������ D �еľ��� �¼Ӿ�
  �������� CE45-B8E3

  D:\Python\s014\DAY2 ��Ŀ¼

 2017/01/08  18:55    <DIR>          .
 2017/01/08  18:55    <DIR>          ..
 2017/01/08  18:55               340 sys_import.py
                1 ���ļ�            340 �ֽ�
                2 ��Ŀ¼ 37,835,616,256 �����ֽ�
 ********>>>>> 0

0表示成功

换一种方法

 import os

 cmd_comand=os.popen("dir")
 print("********>>>>>",cmd_comand)

【执行结果】

打印的是一串内存地址

 ********>>>>> <os._wrap_close object at 0x00000000006DD860>

 import os

 cmd_comand=os.popen("dir").read()  # 从内存里读出结果，调用read方法，读出结果
 print("********>>>>>",cmd_comand)

 ********>>>>>  驱动器 D 中的卷是 新加卷
  卷的序列号是 CE45-B8E3

  D:\Python\s014\DAY2 的目录

 2017/01/08  19:05    <DIR>          .
 2017/01/08  19:05    <DIR>          ..
 2017/01/08  19:05               402 sys_import.py
                1 个文件            402 字节
                2 个目录 37,835,595,776 可用字节

【创建目录】

 import os

 os.mkdir("new_dir")

自己写一个模块

【引入模块，运行】

在sys_import.py中引入login模块

 import login

【运行结果】

 输入用户名：alex
 输入密码：abc123
 Welcome user alex ,login......

把文件移走

找不到了，变红了，默认从当前，目录找模块，当前目录没有再去全局环境变量中找

 Traceback (most recent call last):
   File "D:/Python/s014/DAY2/sys_import.py", line 3, in <module>
     import login
 ImportError: No module named 'login'

***Python35\\lib\\site-packages***将login.py放到这个位置，再运行

 import login

 可以正常运行

这个“__pycache__”路径下生成一个文件

3、.pyc是个什么鬼?

1. Python是一门解释型语言？

　　我初学Python时，听到的关于Python的第一句话就是，Python是一门解释性语言，我就这样一直相信下去，直到发现了*.pyc文件的存在。如果是解释型语言，那么生成的*.pyc文件是什么呢？c应该是compiled的缩写才对啊！

为了防止其他学习Python的人也被这句话误解，那么我们就在文中来澄清下这个问题，并且把一些基础概念给理清。

2. 解释型语言和编译型语言

　　计算机是不能够识别高级语言的，所以当我们运行一个高级语言程序的时候，就需要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分成两类，第一种是编译，第二种是解释。

　　编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言。

　　解释型语言就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行作出解释，然后直接运行，最典型的例子是Ruby。

　　通过以上的例子，我们可以来总结一下解释型语言和编译型语言的优缺点，因为编译型语言在程序运行之前就已经对程序做出了“翻译”，所以在运行时就少掉了“翻译”的过程，所以效率比较高。但是我们也不能一概而论，一些解释型语言也可以通过解释器的优化来在对程序做出翻译时对整个程序做出优化，从而在效率上超过编译型语言。

此外，随着Java等基于虚拟机的语言的兴起，我们又不能把语言纯粹地分成解释型和编译型这两种。

　　用Java来举例，Java首先是通过编译器编译成字节码文件，然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。

3. Python到底是什么

　　其实Python和Java/C#一样，也是一门基于虚拟机的语言，我们先来从表面上简单地了解一下Python程序的运行过程吧。当我们在命令行中输入python hello.py时，其实是激活了Python的“解释器”，告诉“解释器”：你要开始工作了。可是在“解释”之前，其实执行的第一项工作和Java一样，是编译。熟悉Java的同学可以想一下我们在命令行中如何执行一个Java的程序：

javac hello.java

java hello

　　只是我们在用Eclipse之类的IDE时，将这两部给融合成了一部而已。其实Python也一样，当我们执行python hello.py时，他也一样执行了这么一个过程，所以我们应该这样来描述Python，Python是一门先编译后解释的语言。

4. 简述Python的运行过程

　　在说这个问题之前，我们先来说两个概念，PyCodeObject和pyc文件。

我们在硬盘上看到的pyc自然不必多说，而其实PyCodeObject则是Python编译器真正编译成的结果。我们先简单知道就可以了，继续向下看。

　　当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。

　　当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。

所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式。

注：如果源代码被改动，则执行.py文件时，程序会比较.py和.pyc文件的时间，如果源代码的时间是最新的，则会重新编译生成最新的.pyc文件

4、数据类型初识

1、数字

int（整型）Python3中没有长整型，不管多大都是整型

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

float（浮点型）

      先扫盲 http://www.cnblogs.com/alex3714/articles/5895848.html 
　　浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
complex（复数）
　　复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

注：Python中存在小数字池：-5 ～ 257

2、布尔值

真或假

1 或 0

 a=0 # 0——false;1——true
 if a:
     print(a)

输出结果为空，不打印

 a=1 # 0——false;1——true
 if a:
     print(a)

输出结果为1

3、字符串

"hello world"

　　万恶的字符串拼接：

　　python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。

字符串格式化输出

name = "kaka"
print
"i am %s " % name

# 输出: i am kaka

字符串常用功能：

• 移除空白
• 分割
• 长度
• 索引
• 切片

6.字符串常用操作

1.capitalize（首字母大写），count（统计出现次数），center（居中文字，不足替代字符）

 1 name="my name is alex"
 2
 3 print(name.capitalize())#首字母大写
 4 print(name.count("a"))#统计有几个”a“
 5 print(name.center(50,"-"))#移动输出50个字符，不够的用”-“代替
-------------------------------------------------------------
 8 My name is alex
 9 2
10 -----------------my name is alex------------------

2.endswith（以XX结尾）、expandtabs（把tab键转成多少空格）、find（查找）、切片

 1 name="my \tname is alex"
 2
 3
 4 print(name.endswith("ex"))#是不是以"ex"结尾
 5 print(name.expandtabs(tabsize=30))#把tab键转成多少个空格
 6 print(name.find("name"))#查找找到字符的索引，字符串也可以切片
 7 print(name[name.find("name"):9])#字符串切片,到第几个字符结束
--------------------------------------------------------------------------
11 True
12 my                            name is alex
13 4
14 name 

1 name="my name is {name},and age is {age}"
4 print(name.format(name="baby",age="18"))#格式化输出
5 print(name.format_map({"name":"alex","age":"12"}))#输出列表
------------------------------------------------------------------------------
8 my name is baby,and age is 18
9 my name is alex,and age is 12

3.isalpha判断字符串是不是纯英文字符

1 print("asdfDSA".isalpha())#是不是纯英文字符
---------------------------
3 True
4
5 print("asdf1234".isalpha())#是不是纯英文字符
---------------------------
7 False

4.isdecimal判断字符串是不是10进制

1 print("1234.243".isdecimal())#是不是10进制
2 print("1234".isdecimal())#是不是10进制
3 print("1234asd".isdecimal())#是不是10进制
4
------------------------------------------------
6 False
7 True
8 False

5.isidentifier判断是不是和法的标识符——合法的变量名

 1 print("1234.243".isidentifier())#判断是不是合法的标识符
 2 print("——1234.243".isidentifier())#判断是不是合法的标识符
 3 print("_123asdf".isidentifier())#判断是不是合法的标识符
 4 print("_123 asdf".isidentifier())#判断是不是合法的标识符
 5 print("!#$asdf".isidentifier())#判断是不是合法的标识符
 6 print("aaasd_asd".isidentifier())#判断是不是合法的标识符
----------------------------------------------------------------
 9 False
10 False
11 True
12 False
13 False
14 True

6.istitle是不是标题，首字母都大写

1 print("My name is".istitle())#判断是不是标题
2 print("My Name Is".istitle())#判断是不是标题
-----------------------------------------------------------------
5 False
6 True

7.isprintable判断能不能打印

只有tty file,drive file不能打印

1 print("My Name Is".isprintable())#判断是不是可以打印的,tty file,drive file不能打印
----------------------------------------------------------------------------------
4 True

8.isupper判断是不是大写

1 #判断是不是大写
2 print("My Name Is".isupper())
3 print("ddddddddddddddddd".isupper())
4 print("MY NAME IS".isupper())
----------------------------------------------------------------------------------
7 False
8 False
9 True

9.join方法

1 #把列表的内容转成字符串，用分割符分开
2 print(",".join(["111","322","342"]))
-----------------------------------------------------------------------------------
4 111,322,342

10.ljust，rjust

1 print(name.ljust(50,"*"))#输出字符串长度为50，不够的用*左补齐
2 print(name.rjust(50,"-"))#输出字符串长度为50，不够的用-右补齐
-------------------------------------------------------------------------------------
5 my name is {name},and age is {age}****************
6 ----------------my name is {name},and age is {age}

11.大小写转换

1 #大小写转换
2 print("ASDFFDGFDGJGH".lower())
3 print("asdffdgfdgjgh".upper())
-------------------------------------------------------------------------------------
5 asdffdgfdgjgh
6 ASDFFDGFDGJGH

12.去掉左边的空格和回车

 1 #去掉左边的空格和回车
 2 print("Alex\n".lstrip())
 3 print("------------")
 4
 5 print("\nAlex".lstrip())
 6 print("------------")
-------------------------------------------------
10 Alex
11
12 ------------
13 Alex
14 ------------

13.去掉空格和回车

 1 #去掉两边的空格和回车
 2 print("     Alex\n".strip())
 3 print("------------")
 4
 5 print("\nAlex".rstrip())
 6 print("------------")
 7
 8 print("\nAlex      \n".rstrip())
 9 print(".....")
---------------------------------------------
13 Alex
14 ------------
15
16 Alex
17 ------------
18
19 Alex
20 .....

14.随机加密算法

1 #字符串加密算法
2 p=str.maketrans("abcdefghijkl","123456789*#&")
3 print("alex li ".translate(p))
-----------------------------------------------------
6 1&5x &9 

15.替换字符串

1 #字符替换
2 print("alex li ".replace("l","L"))#替换所有
3 print("alex li ".replace("l","L",1))#只替换第1个L
----------------------------------------------------------
6 aLex Li
7 aLex li 

16.rfind

1 print("alex li ".rfind("l"))#找到的字符的
2 print("alex li l i l".rfind("l"))#找到最右面的那个值的下标，返回
---------------------------------------------------------------
5 5
6 12

17.split把字符串分割成数组

 1 #把字符串分割成列表
 2 print("alex li l i l".split())#默认按照空格分割符
 3 print("alex li l i l".split("l"))#按照”l“分割符
 4 print("1+2+3+4+5".split("+"))#按照”+“分割符
 5 print("1+2+3+4+5".split("+"))#按照”+“分割符
 6 print("1+2+\n3+4+5".splitlines())#按照”\n“换行分割符
-----------------------------------------------------------------------
 9 ['alex', 'li', 'l', 'i', 'l']
10 ['a', 'ex ', 'i ', ' i ', '']
11 ['1', '2', '3', '4', '5']
12 ['1', '2', '3', '4', '5']
13 ['1+2+', '3+4+5']

18.swapcase大写变小写小写变大写

1 #大小写转化
2 print("Alex Li is very NB ".swapcase())
---------------------------------------------------------------------------
4 aLEX lI IS VERY nb 

4、bytes类型

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

不管怎样，字符串和字节包之间的界线是必然的，下面的图解非常重要，务请牢记于心：

 msg="我爱北京*"

 print(msg.encode("utf-8"))#转换成二进制

[运行结果]

 b'\xe6\x88\x91\xe7\x88\xb1\xe5\x8c\x97\xe4\xba\xac\xe5\xa4\xa9\xe5\xae\x89\xe9\x97\xa8'

5、列表

基本操作：

• 索引
• 切片
• 追加
• 删除
• 长度
• 切片
• 循环
• 包含

创建列表：

#列表  打印一个空列表
name=[]
print(name)

#输出
[]

1.存储列表的值

name1=['xiaozhang','xiaoli','xiaozhao','xiaosun']
print(name1)

#输出
['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']

2.列表索引取值

name1=['xiaozhang','xiaoli','xiaozhao','xiaosun']
print(name1)#列表取值
print(name1[0],name1[2])

#输出
['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
xiaozhang xiaozhao

3.列表切片取值

name1=['xiaozhang','xiaoli','xiaozhao','xiaosun']
print(name1)
#同时取多个值   ——切片数据
print(name1[1:3])#起始位置包括，结束位置不包括，取的是连续的值

#输出
['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
['xiaoli', 'xiaozhao']

原则：顾头不顾尾

取最后一个值

两种写法，索引和-1

name1=['xiaozhang','xiaoli','xiaozhao','xiaosun']
print(name1)#列表取值
print(name1[3])#取最后一个值

name1=['xiaozhang','xiaoli','xiaozhao','xiaosun']
print(name1)#列表取值
print(name1[-1])#未知长度的列表，取出最后一个值

【以上两段运行结果一样】

['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
xiaosun

取最后两个值

name1=['xiaozhang','xiaoli','xiaozhao','xiaosun']
print(name1)#列表取值
print(name1[-2:])#取最后两个值，值是从左往右数,顾头不顾尾，省略最后一位，才能取出来

省略从0取的值

['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
['xiaozhao', 'xiaosun']

省略前面的值

name1=['xiaozhang','xiaoli','xiaozhao','xiaosun']
print(name1)#列表取值
print(name1[:3])#前面省略也可以

#运行结果
['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
['xiaozhang', 'xiaoli', 'xiaozhao']

取最后两个值

切片必须从左往右切，顺序是左小右大，ps：负数的情况

name1=['xiaozhang','xiaoli','xiaozhao','xiaosun']
print(name1)#列表取值
print(name1[-3:-1])#取最后两个值，出错

#运行结果
['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
['xiaoli', 'xiaozhao']

取最后两个值，切片，-1取不到最后一个值，因为顾头不顾尾。

name1=['xiaozhang','xiaoli','xiaozhao','xiaosun']
print(name1)#列表取值
print(name1[-2:-1])#取最后两个值，出错，固守不顾尾

#输出结果
['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
['xiaozhao']

切片的省略写法

name1=['xiaozhang','xiaoli','xiaozhao','xiaosun']
print(name1)#列表取值
print(name1[:3])#前面省略也可以

#输出结果
['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
['xiaozhang', 'xiaoli', 'xiaozhao']

切片小结：

①序列始终都是从左向右切片的，不能是从右向左

①列表切片时，起始位的元素是包括的，结束位的元素是不包括（又叫顾头不顾尾），最后一个位置表示步长（names[开始位:结束位:步长]）

②如果从0位置取值，0可以省略

③想取最后一个值时，结束位不能是-1，因为结束位的元素不包括，所以只能留空

4.append方法追加,加到最后

#存储列表的值
name1=['xiaozhang','xiaoli','xiaozhao','xiaosun']
#追加内容
name1.append("xiaoma")
print(name1)

#输出结果
['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun', 'xiaoma']

5.insert方法追加，索引位置+值

# 存储列表的值
name1 = ['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
# 追加内容
name1.append("xiaoma")
# 选择并设置插入位置和内容
name1.insert(1, "kaka")
print(name1)

#输出结果
['xiaozhang', 'kaka', 'xiaoli', 'xiaozhao', 'xiaosun', 'xiaoma']

6.修改列表的值

# 存储列表的值
name1 = ['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
# 修改内容，直接改
name1[2] = "star coco"
print(name1)

#输出结果
['xiaozhang', 'xiaoli', 'star coco', 'xiaosun']

注：修改列表中的元素，直接是 names[下标值] = 新值

7.1.删除列表的方法1，remove

# 存储列表的值
name1 = ['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
# 删除的方法1
name1.remove("xiaoli")
print(name1)

#运行结果
['xiaozhang', 'xiaoli', 'star coco', 'xiaosun']

7.2.删除列表的方法2，del

del关键字不仅可以删除列表中的元素，也可以删除变量

#存储列表的值
name1=['xiaozhang','xiaoli','xiaozhao','xiaosun']

#删除的方法2
del name1[1]
print(name1)

#运行结果
['xiaozhang', 'xiaozhao', 'xiaosun']

7.3.删除列表的方法3，pop

如果pop()中有下标值，则是删掉具体某个元素，其效果和del的效果是一样的

# 存储列表的值
name1 = ['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
# 删除的方法3,删掉最后一个值
name1.pop()
# 删除的方法3,name1.pop（）删掉最后一个值，如果输入下标也可以
name1.pop(2)
print(name1)

#运行结果
['xiaozhang', 'xiaoli']

8.index方法

# 存储列表的值
name1 = ['xiaozhang', 'xiaoli', 'xiaozhao', 'xiaosun']
# 查找列表中的内容是第几个元素
print(name1.index("xiaoli"))
print(name1[name1.index("xiaoli")])

#输出结果
1
xiaoli

9.count方法

name1=['xiaozhang','xiaoli','xiaozhao','xiaosun','xiaoli','xiaoli']

#统计有几个同名的
print(name1.count('xiaoli'))

#运行结果
3

10.reserve翻转方法

#存储列表的值
name1=['xiaozhang','xiaoli','xiaozhao','xiaosun','xiaoli','xiaoli']
#name1.clear()#清空
name1.reverse()#反转
print(name1)

#输出结果
['xiaoli', 'xiaoli', 'xiaosun', 'xiaozhao', 'xiaoli', 'xiaozhang']

11.排序列表的值

#存储列表的值
name1=['xiaozhang','xiaoli','xiaozhao','xiaosun','xiaoli','xiaoli']
#name1.clear()#清空
name1.sort()
print(name1)

#输出结果
['xiaoli', 'xiaoli', 'xiaoli', 'xiaosun', 'xiaozhang', 'xiaozhao']

12.合并列表的值

#合并列表的值
#存储列表的值
name1=['1xiaozhang','@xiaoli','axiaozhao','xiaosun','2xiaoli','Xxiaoli']
name2=["1","2","3"]
name1.extend(name2)#合并列表
print(name1)

#输出结果
['1xiaozhang', '@xiaoli', 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli', '1', '2', '3']

#合并列表的值
#存储列表的值
name1=['1xiaozhang','@xiaoli','axiaozhao','xiaosun','2xiaoli','Xxiaoli']
name2=["1","2","3"]
name1.extend(name2)#合并列表
del name2  #删除name2的内容
print(name1)

13.复制列表

注：这边的copy都是浅copy，只能copy第一层。深浅拷贝的详细信息

#存储列表的值
name1=['1xiaozhang','@xiaoli','axiaozhao','xiaosun','2xiaoli','Xxiaoli']
name2=name1.copy()
print(name1)
print(name2)

运行结果
['1xiaozhang', '@xiaoli', 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']
['1xiaozhang', '@xiaoli', 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']

1.复制后改变原列表的值，单层，

结论：原列表，结果改变，新列表不改变

#存储列表的值
name1=['1xiaozhang','@xiaoli','axiaozhao','xiaosun','2xiaoli','Xxiaoli']
name2=name1.copy()

name1[1]="可乐宝宝"#改变内容
print(name1)
print(name2)

#输出内容
['1xiaozhang', '可乐宝宝', 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']
['1xiaozhang', '@xiaoli', 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']

2.复制后改变原列表的值，嵌套列表，

结论：原列表，结果改变，新列表不改变

#存储列表的值
name1=['1xiaozhang','@xiaoli',["alex","tom","java"],'axiaozhao','xiaosun','2xiaoli','Xxiaoli']
name2=name1.copy()

name1[1]="可乐宝宝"#改变内容
print(name1)
print(name2)

#输出内容
['1xiaozhang', '可乐宝宝', ['alex', 'tom', 'java'], 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']
['1xiaozhang', '@xiaoli', ['alex', 'tom', 'java'], 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']

3.复制后改变原列表的值，嵌套列表，

结论：原列表，结果改变，新列表不改变；改变嵌套列表的内容，两个列表的值都被改变

#存储列表的值
name1=['1xiaozhang','@xiaoli',["alex","tom","java"],'axiaozhao','xiaosun','2xiaoli','Xxiaoli']
name2=name1.copy()

name1[1]="可乐宝宝"#改变内容
name1[2][0]="ALEXANDHE"#修改嵌套列表中的内容
print(name1)
print(name2)

#输出结果
['1xiaozhang', '可乐宝宝', ['ALEXANDHE', 'tom', 'java'], 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']
['1xiaozhang', '@xiaoli', ['ALEXANDHE', 'tom', 'java'], 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']

浅copy，深copy

浅copy，只copy第一层

存储列表的值 ,列表可以嵌套列表，["alex","tom","java"]存的是内存地址，copy的是内存地址，第一层会独立克隆

import copy

# 存储列表的值 ,列表可以嵌套列表，["alex","tom","java"]存的是内存地址
name1 = ['1xiaozhang', '@xiaoli', ["alex", "tom", "java"], 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']
name2 = copy.copy(name1)
name1[1] = "可乐宝宝"  # 改变内容
name1[2][0] = "ALEXANDHE"  # 修改嵌套列表中的内容 ，
print(name1)
print(name2)

#运行结果
['1xiaozhang', '可乐宝宝', ['ALEXANDHE', 'tom', 'java'], 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']
['1xiaozhang', '@xiaoli', ['ALEXANDHE', 'tom', 'java'], 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']

深copy，没有同时改变嵌套列表中的值

import copy

# 存储列表的值 ,列表可以嵌套列表，["alex","tom","java"]存的是内存地址
name1 = ['1xiaozhang', '@xiaoli', ["alex", "tom", "java"], 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']
name2=copy.deepcopy(name1)#深深的copy
name1[1] = "可乐宝宝"  # 改变内容
name1[2][0] = "ALEXANDHE"  # 修改嵌套列表中的内容 ，
print(name1)
print(name2)

#输出结果
['1xiaozhang', '可乐宝宝', ['ALEXANDHE', 'tom', 'java'], 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']
['1xiaozhang', '@xiaoli', ['alex', 'tom', 'java'], 'axiaozhao', 'xiaosun', '2xiaoli', 'Xxiaoli']

7.字典

常用操作：

• 索引
• 新增
• 删除
• 键、值、键值对
• 循环
• 长度

字典key:value形式存储,字典是无序的，没有下标。

key必须是唯一的,so 天生去重

 info={
      "stu00001":"xiao lin",
      "stu00002":"xiao li",
      "stu00003":"xiao zhao",
      "stu00004":"xiao wang",
      "stu00005":"xiao zhang"
 }
 print(info)#无序的
 print(info["stu00001"])#用key取值

---------------------------------------------------
 {'stu00002': 'xiao li', 'stu00001': 'xiao lin', 'stu00003': 'xiao zhao', 'stu00005': 'xiao zhang', 'stu00004': 'xiao wang'}
 xiao lin

1.修改

 info={
      "stu00001":"xiao lin",
      "stu00002":"xiao li",
      "stu00003":"xiao zhao",
      "stu00004":"xiao wang",
      "stu00005":"xiao zhang"
 }

 info["stu00001"]="小钟"#修改已存在的
 info["stu00006"]="小宝"#修改不存在的，增加

 print(info)#无序的
 print(info["stu00001"])#用key取值

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

 {'stu00001': '小钟', 'stu00003': 'xiao zhao', 'stu00005': 'xiao zhang', 'stu00002': 'xiao li', 'stu00004': 'xiao wang', 'stu00006': '小宝'}
 小钟 
 小宝

2.删除

 info={
      "stu00001":"xiao lin",
      "stu00002":"xiao li",
      "stu00003":"xiao zhao",
      "stu00004":"xiao wang",
      "stu00005":"xiao zhang"
 }

 del info["stu00001"]
 info.pop("stu00002")
 info.popitem()#随机删除一个
 print(info)#无序的

--------------------------------------------------------
 {'stu00004': 'xiao wang', 'stu00003': 'xiao zhao'}

2.1删除不存在的值会报错

 info={
      "stu00001":"xiao lin",
      "stu00002":"xiao li",
      "stu00003":"xiao zhao",
      "stu00004":"xiao wang",
      "stu00005":"xiao zhang"
 }

 #这样写不存在的值会报错
 info["stu00006"]

 print(info)#无序的

-------------------------------------------------------------------
 File "D:/Python/s014/DAY2/dictionary.py", line 13, in <module>
     info["stu00006"]

2.2判断字典里是否存在的方法

 info={
      "stu00001":"xiao lin",
      "stu00002":"xiao li",
      "stu00003":"xiao zhao",
      "stu00004":"xiao wang",
      "stu00005":"xiao zhang"
 }

 #判断值在字典里是否存在
 print("stu00001" in info)
 print("stu00011" in info)

-------------------------------------------------------
 True
 False

3.多级字典

 # __author__ = 'huojia'

 av_catalog = {
     "欧美":{
         "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
         "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
         "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
         "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
     },
     "日韩":{
         "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
     },
     "大陆":{
         "":["全部免费,真好,好人一生平安","服务器在国外,慢"]
     }
 }
 #修改内容，key尽量不要写中文
 av_catalog["大陆"][""][1] += ",可以用爬虫爬下来"
 print(av_catalog["大陆"][""])
 av_catalog.setdefault("*","www.baidu.com")#取不到值，就新增一个
 av_catalog.setdefault("大陆","www.baidu.com")#能取到就，就不更新了

 print(av_catalog)
-----------------------------------------------------------------------------------
 ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']
 {'日韩': {'tokyo-hot': ['质量怎样不清楚,个人已经不喜欢日韩范了', '听说是收费的']}, '*': 'www.baidu.com', '欧美': {'x-art.com': ['质量很高,真的很高', '全部收费,屌比请绕过'], 'www.youporn.com': ['很多免费的,世界最大的', '质量一般'], 'www.pornhub.com': ['很多免费的,也很大', '质量比yourporn高点'], 'letmedothistoyou.com': ['多是自拍,高质量图片很多', '资源不多,更新慢']}, '大陆': {'': ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']}}

3.1 update合并两个字典

update()是把两个字典合并成一个新的字典，中间有交叉的key，更新替换成新值，没有交叉就直接创建

 info={
      "stu00001":"xiao lin",
      "stu00002":"xiao li",
      "stu00003":"xiao zhao",
      "stu00004":"xiao wang",
      "stu00005":"xiao zhang"
 }
 b={
    "stu00001":"Alex",
    1:5,
    6:3
 }
 info.update(b)#合并两个字典，存在即更新，不存在即添加

 print(info)

----------------------------------------------------------------------------------------------------------------------------------------
 {1: 5, 6: 3, 'stu00003': 'xiao zhao', 'stu00004': 'xiao wang', 'stu00005': 'xiao zhang', 'stu00001': 'Alex', 'stu00002': 'xiao li'}

注：以后提到更新(update),就是直接原有的字典或者列表上修改

3.2 fromkeys

初始化一个字典，创建在一个内存地址上，

注:创建多层会有浅copy的作用，所以不建议使用，只需要做了解即可

 c=dict.fromkeys([6,7,8],[1,{"name","alex"},444])

 print(c)
--------------------------------------------------------------------------------------------------
6 {6: [1, {'alex', 'name'}, 444], 7: [1, {'alex', 'name'}, 444], 8: [1, {'alex', 'name'}, 444]}

3.3 效率最高的循环方式

 info={
      "stu00001":"xiao lin",
      "stu00002":"xiao li",
      "stu00003":"xiao zhao",
      "stu00004":"xiao wang",
      "stu00005":"xiao zhang"
 }

 for i in info:
     print(i)#只打印key
     print(i,info[i])#打印value
--------------------------------------------

stu00005
stu00005 xiao zhang
stu00002
stu00002 xiao li
stu00001
stu00001 xiao lin
stu00004
stu00004 xiao wang
stu00003
stu00003 xiao zhao

3.4 不建议使用的低效率循环

 info={
      "stu00001":"xiao lin",
      "stu00002":"xiao li",
      "stu00003":"xiao zhao",
      "stu00004":"xiao wang",
      "stu00005":"xiao zhang"
 }

 for k,v in info.items():#字典转列表操作，数据量大的时候非常耗费时间
     print(k,v)
--------------------------------
 stu00004 xiao wang
 stu00005 xiao zhang
 stu00002 xiao li
 stu00001 xiao lin
 stu00003 xiao zhao

小结：

①方法1的效率比方法2的效率高很多

②方法1是直接通过key取value

③方法2是先把字典转换成一个列表，再去取值

④当数据量比较大的时候，用第二种方法时，字典转换成列表的这个过程需要花大量的时间老转换，当然数据量不大，没有关系，效率差不多

字典的其他用法

1、values()

返回字典中所有value，生成一个列表

>>> stu_info = {"zhangsan":23,"lisi":18,"wangwu":18}
>>> stu_info.values()
#输出
dict_values([23, 18, 18])

2、keys()

返回字典中所有key，生成一个列表

>>> stu_info = {"zhangsan":23,"lisi":18,"wangwu":18}
>>> stu_info.keys()
#输出结果
dict_keys(['zhangsan', 'wangwu', 'lisi'])

3、setdefault(k,v)

setdefault()表示去取字典中的key，如果取不到，则设置新值，相反如果取到，则返回字典中原有值

>>> stu_info = {"zhangsan":23,"lisi":18,"xiaoming":18}
#设置不存在的key
>>> stu_info.setdefault("wanger",25)
25
>>> stu_info
#输出结果
{'wanger': 25, 'zhangsan': 23, 'xiaoming': 18, 'lisi': 18}
#设置存在的key
>>> stu_info.setdefault("xiaoming",23)
18
>>> stu_info
#输出结果
{'wanger': 25, 'zhangsan': 23, 'xiaoming': 18, 'lisi': 18}

4、items()

把字典转换成列表

>>> stu_info = {"张三":23,"李四":18,"小明":18}
>>> stu_info.items()
dict_items([('李四', 18), ('小明', 18), ('张三', 23)])

5、clear()

清空字典

>>> stu_info = {"张三":23,"李四":18,"小明":18}
>>> stu_info.clear()
#输出
>>> stu_info
{}

View Cod

8、 三元运算

1 result = 值1 if 条件 else 值2

如果条件为真：result = 值1

如果条件为假：result = 值2

1 a,b,c=1,2,3
2
3 d= a if a>b  else c
4 #如果a>b ,d=a,else d=c
5 print(d)

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

3

1 a,b,c=1,2,3
2
3 d= a if a<b  else c
4 #如果a<b ,d=a,else d=c
5 print(d)

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

1

以上代码等同于

1 if a>b :
2     d=a
3 else:
4     d=c
5 print(d)

9、进制

• 二进制，01
• 八进制，01234567
• 十进制，0123456789
• 十六进制，0123456789ABCDEF

二进制到16进制转换

每4个2进制表示一个16进制，为什么是每4个呢？因为2的4次方表示最大到15.

http://jingyan.baidu.com/album/47a29f24292608c0142399cb.html?picindex=1

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

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

计算机内存地址和为什么用16进制？

为什么用16进制

1、计算机硬件是0101二进制的，16进制刚好是2的倍数，更容易表达一个命令或者数据。十六进制更简短，因为换算的时候一位16进制数可以顶4位2进制数，也就是一个字节（8位进制可以用两个16进制表示）

2、最早规定ASCII字符集采用的就是8bit(后期扩展了,但是基础单位还是8bit)，8bit用2个16进制直接就能表达出来，不管阅读还是存储都比其他进制要方便
3、计算机中CPU运算也是遵照ASCII字符集，以16、32、64的这样的方式在发展，因此数据交换的时候16进制也显得更好
4、为了统一规范，CPU、内存、硬盘我们看到都是采用的16进制计算

16进制用在哪里
1、网络编程，数据交换的时候需要对字节进行解析都是一个byte一个byte的处理，1个byte可以用0xFF两个16进制来表达。通过网络抓包，可以看到数据是通过16进制传输的。
2、数据存储，存储到硬件中是0101的方式，存储到系统中的表达方式都是byte方式
3、一些常用值的定义，比如：我们经常用到的html中color表达，就是用的16进制方式，4个16进制位可以表达好几百万的颜色信息。

程序练习

程序: 三级菜单

要求:

1. 打印省、市、县三级菜单
2. 可返回上一级
3. 可随时退出程序

menu_list ={
 "A":{
  "A1":["A101","A102","A103","A104"],
  "A2":["A201","A202","A203","A204"],
  "A3":["A301","A302","A303","A304"]
 },
  "B":{
  "B1":["B101","B102","B103","B104"],
  "B2":["B201","B202","B203","B204"],
  "B3":["B301","B302","B303","B304"]
 },
 "C":{
  "C1":["C101","C102","C103","C104"],
  "C2":["C201","C202","C203","C204"],
  "C3":["C301","C302","C303","C304"]
 },
 "D":{
  "D1":["D101","D102","D103","D104"],
  "D2":["D201","D202","D203","D204"],
  "D3":["D301","D302","D303","D304"]
 },
}

count = 0
back_to_up=0
while count < 3:
    #print("count value:",count) #记录星星次数
    #print("back_to_up value:",back_to_up) #记录返回哪一级菜单
    if back_to_up !=2:
        for i in menu_list:
            print ("列出一级菜单项**************",i)
        first_name_select = input("请选择以上列出的一级菜单项输入:")

    count=count+1
    if first_name_select in menu_list or back_to_up==2:
        first_name=menu_list[first_name_select]
        second_name=first_name.keys()
        for i in second_name:
            print("列出二级菜单项**************",i)
        back_or_quit = input("二级级菜单处是否退出？按b:返回;按q:退出整个程序,按回车继续")
        if back_or_quit == "q":
            break
        elif back_or_quit == "b":
            back_to_up=1
            if count != 0:
                count=count-1
            continue
        else:
            second_name_select = input("请输入二级级菜单项:")
            if second_name_select in second_name:
                third_name = menu_list[first_name_select][second_name_select]
                for i in third_name:
                    print("列出三级菜单项**************",i)
                else:
                    back_or_quit = input("三级菜单处是否退出？按b:返回;按q:退出整个程序")
                    if back_or_quit == "q":
                        break
                    if back_or_quit == "b":
                        back_to_up=2
                        if count != 0:
                            count=count-1
                        continue
            else:
                print("您的输入在二级菜单中不存在")
                back_to_up=2
                continue
    else:
        print("您的输入在一级菜单中不存在,请重新输入")
        back_to_up=1
        continue

else:
    back_to_up=0
    print("您的尝试太多次了,不可以再试了，请退出再见！")

购物车

购物车知识点

1、enumenrate()用法

enumenrate()是Python自带的函数，主要用于列表或者元组，功能:是在for循环时，获取列表或者元组的下标值和元素

①下标和元素以元组形式输出

>>> name_list = [('a',1),('b',2)]
>>> for index in enumerate(name_list):
...     print(index)
...
#输出结果，获取到的是以元组形式输出，每个元组第一个值表示name_list下标值，第二个值表示name_list的元素
(0, ('a', 1))
(1, ('b', 2))

②下标值和元素分开输出

>>> name_list = [('a',1),('b',2)]
>>> for index,name in enumerate(name_list):
...     print(index,name)
...
#第一个值name_list的下标值，第二个是name_list的元素
0 ('a', 1)
1 ('b', 2)

2、isdigit()用法

是数字返回true,就强行转换成int，不是数字就返回false

salary=input("请输入你的工资:")
if salary.isdigit():
    salary = int(salary)
else:
    print("您输入的工资不是数字！")

小结：

isdigit()方法是判断字符本身是否是一个数字类型（int）类型，如果是数字类型的话，则返回Ture,不是数字类型的话，返回False

代码

salary=input("第一次登陆请输入你的工资>>>")
            Proc_info=[
                  ("Book",100),
                  ("Node Book",9800),
                  ("IPhone 7 Plus",7188),
                  ("key bords",500),
                  ("Shoes",800),
                  ("Coffee",50),
                  ("whoo",3000),
                  ("pen",865),
                  ("Ring",19999),
                  ("Watch",8999)
                ]
            temp_list=[]
            if salary.isdigit():
                salary=int(salary)
                while True:
                    print("您要买什么，请看商品列表")
                    for index,item in enumerate(Proc_info):
                        print(index,item)
                    user_select=input("[按“q”退出结账]请选择你需要购买的商品：>>")
                    if user_select.isdigit():
                        user_select=int(user_select)
                        if user_select < len(Proc_info) and user_select>=0:
                            p_item=Proc_info[user_select]
                            temp_list.append(p_item)
                            if p_item[1]<=salary:#买得起
                                salary = salary- p_item[1]
                                print("把\033[31;1m%s\033[0m加入购物车，剩下的钱是\033[31;1m%d\033[0m" %(p_item[0],salary))
                            else:
                                print("\033[31;1m就剩下%d，买不起啦！\033[0m"%salary)
                        else:
                            print("输入的[%s]商品不存在"%user_select)
                    elif user_select=="q":
                        print("------------shopping list-------------")
                        for p in temp_list:
                            print(p)
                        print("\033[31;1m你的余额%d\033[0m"%salary)
                        if len(temp_list):
                            if username in dict3 :#更新user信息到集合中
                                file=open("log","w",encoding="utf-8")
                                dict3[username]["salary"]=salary
                                dict3[username]["goods"]+=temp_list
                                file.write(str(dict3))
                                file.close()
                            else:#不存在集合中的用户，追加写入集合中，替换末尾的“}”
                                file_i_n=open("log","w",encoding="utf-8")
                                file_i_n.write(str(dict3).replace("}}","}"))
                                file1=open("log","a+",encoding="utf-8")
                                newstr=",\""+username+"\":{"+"\"salary\""+":\""+str(salary)+"\",\"goods\":"+str(temp_list)+"}}"
                                file1.write(newstr)
                                file_i_n.close()
                                file1.close()
                            exit()
                        else:
                            print("没有购买任何商品,再见！")
                            exit()
                    else:
                        print("商品编号输入错误，必须要是数字。。。")
            else:
                print("您输入的工资不是数字！")
                continue