Python Day2

本节知识点：

1.模块初识，python代码运行方式

2.数据类型

3.布尔值

4.列表

5.元组

6.购物车小程序

7.字典

8.深copy，浅copy

一.模块初识

什么是模块？

在Python中有一个概念叫做模块（module），如果我们要在Python中实现某一项功能的时候，就需要用到模块了，模块一般被称为标准库，及第三方库

那么我们接下来看看模块是怎么使用的.

导入模块

首先我们来看看常用的os模块和sys模块.

sys模块：

sys.path：打印相对路径

# _author_=AbeoHu
import sys
print(sys.path)

sys.argv:打印绝对路径

# _author_=AbeoHu
import sys
print(sys.argv)

 os模块：

os模块主要是作为和系统交互的模块

os.system  操作系统中的命令

# _author_=AbeoHu
import os
os.system("ipconfig")

os.popen

# _author_=AbeoHu
import os
print(os.popen("ipconfig"))#打印内存对象
print(os.popen("ipconfig").read())#通过read调取出值

 os.mkdir

# _author_=AbeoHu
import os
os.mkdir("AbeoHu")#创建新的目录

Python的运行过程：

首先咱们先来介绍一下PyCodeobject：

Python先把代码（.py文件）编译成字节码，交给字节码虚拟机，然后虚拟机一条一条执行字节码指令，从而完成程序的执行。相当于一个编译器。

pyc是什么鬼？

pyc是一种二进制文件，是由py文件经过编译后，生成的文件，是一种byte code，py文件变成pyc文件后，加载的速度有所提高，而且pyc是一种跨平台的字节码，是由Python的虚拟机来执行的

那么Python代码是怎么执行的呢？

PYthon 执行会先找pyc文件，如果没有，通过PyCodeobject进行编译，然后生成pyc文件，下次直接调取

　　　　　　　　　　　　　　　　　　

二.数据类型

什么是数据类型？

计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种：

整数：整数分为整数和长整数，整数就是数字，长整数就是长一点的整数

浮点数：浮点数代表小数，类似于如1.23，3.14，-9.01，等等。

字符串：字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。

那么怎么去判断一个数据是什么类型呢？

type（）

# _author_=AbeoHu
print (type("1"))#打印数据类型

#小记

长整数数据类型long，python3中没有长整数这个概念，so 忘掉他把.

整数运算

3大类型

and  or  not

and：就是和的意思，两个条件要完全匹配才正确

# _author_=AbeoHu
a = 1
b = 2
print(a > 2 and b < 1)

False

很显然，两者中间有条件不符合，显示False

or：或，两者中有一者符合条件正确

# _author_=AbeoHu
a = 1
b = 2
print(a < 2 or b < 1)

True

有一个条件满足，返回True

not：取反

# _author_=AbeoHu
a = 1
b = 2
print(not a > 2 and b > 1)

True

取反，将错误的表示正确的，正确的显示错误的

 预算符：

in  存在

# _author_=AbeoHu
a = "111111111111111111111111111111"
print('2' in a)#打印结果

False

 not in  不存在

# _author_=AbeoHu
a = "111111111111111111111111111111"
print('2' not in a)#打印结果

True

身份运算符：

is

# _author_=AbeoHu
a = "111111111111111111111111111111"
print(type(a) is str)#判断变量a是否是字符串

is not

# _author_=AbeoHu
a = "111111111111111111111111111111"
print(type(a) is not str)#判断变量a是否不是字符串

 三.布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：

>>> True
True
>>> False
False
>>> 3<2
False
>>> 3>2
True

 布尔值也可以用and not or运算：

# _author_=AbeoHu
5 > 3 and 3 > 1
True
5 > 3 or 1 > 3
True
not 1 > 2
True

四.列表

1.什么是列表

列表是Python中最基本的数据结构，列表是最常用的Python数据类型，列表的数据项不需要具有相同的类型。

2.列表的使用方法

首先介绍列表的格式：

# _author_=AbeoHu
a = ['AbeoHu','QQ','jack']#列表格式中间用，隔开，中括号括住

如果我要将AbeoHu过滤出来：

首先，列表的数是从0开始的，那么AbeoHu代表0，我们把0过滤出来

# _author_=AbeoHu
a = ['AbeoHu','QQ','jack']#列表格式中间用，隔开，中括号括住
print(a[0])

如果要追加内容到里面呢？ .append

a.append('xiaohu')

插入到指定位置  insert

a.insert(2,'xiaohu')

删除 remove

a.remove('xiaohu')

找到里面有几个相同元素在里面  count

print(a.count('xiaohu'))

查找元素所在的位置 index

print(a.index('xiaohu'))

如果想把他们倒过来呢？ reverse

a.reverse()

排序，Python默认是按照特殊字符 ，数字，字母排序的  sort

a.sort()

3.切片

切片：Python切片指的是如果我想提取出中间一部分的数据的话，就需要用到切片了

首先，我们先来定义一个列表：

a = ['AbeoHu','QQ','jack','john']

如果我现在想将AbeoHu到jack的元素调取出来，怎么切

首先，我们先来讲讲python切片的特性：

顾头不顾尾，看代码

那我是不是得从0切到2是吧

print(a[0:2])
['AbeoHu', 'QQ']#结果

这就是顾头不顾尾，python切片的时候要往后转移一位，比如你要切第3个，那么你的位置就要定义到4

取前3个元素

print(a[:3])

取后3个元素

print(a[-3:])

我们来定义一个大数字，1-100

L=list(range(100))

现在我想隔两个取一个元素

print(L[::2])

五.元组

什么是元组？

元组一般被称为常量数组，他和列表的区别在于，列表可以改变，元组不能改变.

元组写法：

# _author_=AbeoHu
a = (1,2,3)

元组用法：

count(位置)

a = (1,2,3)
print(a.count(2))

index（查找）

# _author_=AbeoHu
a = (1,2,3)
print(a.index(3))

将元组修改成列表

# _author_=AbeoHu
a = (1,2,3)
a = list(a)

六.购物车小程序

# _author_=AbeoHu
shop_list = [
    ('IPhone',10000),
    ('iPAD',500),
    ('coffie',200)
]
decide = True
shop=[]
sallay = input("please your sally:")
if sallay.isdigit():
    sallay = int(sallay)
    while decide:
        for index,item in enumerate(shop_list):
            print(index,item)
        user_cholice=input("请输入你的商品编号:")
        if user_cholice.isdigit():
            user_cholice=int(user_cholice)
            if user_cholice < len(shop_list) and user_cholice >=0:
                pitem=shop_list[user_cholice]
                if pitem[1] < sallay:
                    shop.append(pitem[0])
                    sallay -= pitem[1]
                    print("您购买了%s,余额还有%d" %(pitem[0],sallay))
                else:
                    print("您的余额已不足。还剩%s"%sallay)
                    for i in shop:
                        print(i)
                    decide=False
            else:
                print("您输入的商品编号不存在")
        elif user_cholice=='q':
            decide=False
        else:
            print("请输入正确的商品编号")
else:
    print("工资为数字格式请重新输入")

七.字典

dict：

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

举个例子，我们写一个成绩表，名字对应成绩

用list（列表）写的话，我们得需要定义两个list

# _author_=AbeoHu
name = ['AbeoHu','QQ','John']
scores = ['99','88','77']

如果用字典的话，只需要定义他的key和值

# _author_=AbeoHu
d = {'AbeoHu':'99','QQ':'88','John':'66'}
print(d['AbeoHu']

如果我现在在外面给AbeoHu定义个新的值，会怎么样？

# _author_=AbeoHu
d = {'AbeoHu':'99','QQ':'88','John':'66'}
d['AbeoHu'] = '222'
print(d)

{'AbeoHu': '222', 'QQ': '88', 'John': '66'}

他会替换

删除key  pop

d.pop('AbeoHu')

d.popitem() 不指定，随机删除

循环打印字典：

方法一：

# _author_=AbeoHu
d = {'AbeoHu':'99','QQ':'88','John':'66'}
for i in d:
    print(i, d[i])

方法2：

# _author_=AbeoHu
d = {'AbeoHu':'99','QQ':'88','John':'66'}
for k,v in d.items():
    print(k,v)

这两种方法区别：

方法1会直接将字典打印出来

方法2首先是将字典转换成列表然后再打印，.items 会变成一个列表

方法1效率要比2高

字典的用法：

.get 返回值，正确不反回，不正确返回none

print(d.get('qq'))

has_key 判断key是否存在，存在返回True，不存在返回False

setdefault 如果字典里没有这个key 就会生成，如果有，按字典的来

d.setdefault('qq')

update 旧的替换掉，新的增加

# _author_=AbeoHu
d = {'AbeoHu':'99','QQ':'88','John':'66'}
d2={'AbeoHu':'222'}
d.update(d2)
print(d)

九.深copy和浅copy用法

 首先我们先来看看字典的案例：

# _author_=AbeoHu
d = {'AbeoHu':'99','QQ':'88','John':'66'} #定义一个字典
d2 = d #将变量指向字典
d['AbeoHu']='200' #修改字典的元素
print(d2)#查看变量d2变量

那么d2变量变不变？

{'QQ': '88', 'AbeoHu': '200', 'John': '66'} #d2也会跟着变

这是为什么？我们先来看看这两个变量的内存地址：

print(id(d))
print(id(d2))
2480295225288
2480295225288

两个id内存地址都一样，在python中是这样的，字典是为了减少内存地址，所以你不论变哪个，字典里对的元素也会跟着变

浅copy:

浅copy是完全独立的，咱们来举个例子

# _author_=AbeoHu
d = {'AbeoHu':'99','QQ':'88','John':'66'} #定义一个字典
d2=d.copy()#copy字典
d['AbeoHu']='222'#修改源字典
print(d)#打印d字典
print(d2)#打印copy的字典

{'AbeoHu': '222', 'QQ': '88', 'John': '66'}
{'AbeoHu': '99', 'QQ': '88', 'John': '66'}

发现，copy的字典元素没变，这是因为字典是独立的

copy本身是copy最深一层的，比如，我们在字典里面增加一个列表

# _author_=AbeoHu
d = {'AbeoHu':['99'],'QQ':'88','John':'66'} #定义一个字典
d['x']=['222','www']#修改源字典
d2=d.copy()#copy字典
d['x'].append('xxxxxxxxxxxxxxxx')
print(d)#打印d字典
print(d2)#打印copy的字典
结果
{'QQ': '88', 'AbeoHu': ['99'], 'x': ['222', 'www', 'xxxxxxxxxxxxxxxx'], 'John': '66'}
{'AbeoHu': ['99'], 'QQ': '88', 'John': '66', 'x': ['222', 'www', 'xxxxxxxxxxxxxxxx']}

发现变了，copy是copy最深一层的

深copy

import copy
copy.deepcopy()#深copy  完全独立克隆一份
copy.copy()#浅copy