Python学习笔记二

1.　　python几种数据类型的比较

　　　　1.　　是否可变。

　　　　　　　　不可变类型：变量的值可以发生变化，id也变了，相当于创建了一个新的对象，所以一修改值,id就变了，这种类型称之为不可变类型。
　　　　　　　　可变类型：变量的值可以发生变化，而且 id不会变，所以称之为可变类型。

#数字类型样例
x=10
print (id(x))
输出：1374668752

#修改x的值为100，看看id变了吗？
x=100
print (id(x))
输出：1374671632
可以看到值修改了，id也变了，无法做到修改值，而保持id不变，所以数字类型属于不可变类型。

#字符串样例：
x='yangjianbo'
print(x,id(x))
#修改x的值，两个id比较一下，是否相同。
x='wangyanhe'
print(x,id(x))
输出的结果： 发现字符串的值被修改了，同时它的id也发生了变化，说明是产生了一个新的引用，所以字符串类型也是不可变类型。

# 列表样例：
x = ['yangjianbo', 'wangyanhe', 'gaozhongmin']
print (x, id(x))
# 修改一下某个元素，看看列表x，id是否变化。
x[0] = 'gushuwei'
print (x, id(x))
输出的结果：
['yangjianbo', 'wangyanhe', 'gaozhongmin']
37527688
['gushuwei', 'wangyanhe', 'gaozhongmin']
37527688
结论：修改列表中的某个元素，不会影响整个列表的id，所以列表属于可变类型。

# 元组样例：
x = ('yangjianbo', 'wangyanhe', 'gaozhongmin')
print (x, id(x))
x[0] = 'gushuwei'
print (x, id(x))
输出结果：直接报错，因为元组只可读，不能写。
结论：元组是不可变类型。

# 字典
x = {'name': 'yangjianbo', 'age': 10, 'bumen': 'xitongbu'}
print (x, id(x))
x['name'] = 'wangyanhe'
print (x, id(x))
输出结果：
{'name': 'yangjianbo', 'age': 10, 'bumen': 'xitongbu'}
31218928
{'name': 'wangyanhe', 'age': 10, 'bumen': 'xitongbu'}
31218928
结论：字典的值可以修改，而且id不会发生变化，所以字典属于可变类型。

　　　　2.　　有序或无序。

　　　　　　　　有序和无序，数据类型能否按照索引的方式，读出数据。

#数字类型

x=10
print (x[0])

结论：报错了，数字类型，无法使用索引读出，它不是一个有序的数据类型。
#字符串

x='aabbcc4455'
print (x[9])

结论：字符串可以通过索引读取字符串中的字符，字符串是有序的数据类型。
#列表

x=['yangjianbo','wangyanhe','gaozhongmin']
print  (x[0])

结论：列表读取某个元素，必须指定元素的索引，所以列表是有序的数据类型。

#元组

x=('yangjianbo','wangyanhe','gaozhongmin')
print (x[0])    
结论：元组读取某个元素，必须指定元素的索引，所以元组是有序的数据类型。 

#字典

x={'name':'yangjianbo','age':10,'bumen':'xitongbu'}
print (x['name'])
结论：字典读取其中的某个值，必须指定键名称，不能按照索引进行读取。所以字典不是有序的数据类型。

　　　　3.　　是否可读写。

　　　　　　　　除了元组不可写，其他类型都支持读写。

　　　　4.　　存一个值还是多个值。

　　　　　　　　数字类型只有一个值，

　　　　　　　　字符串也只有一个值

　　　　　　　　列表多个值

　　　　　　　　元组多个值

　　　　　　　　字典多个值

2.　　数字类型的一些功能

两个变量交换数值。
x=10
y=20
print (x,id(x))
print (y,id(y))
x,y=y,x
print (x,id(x))
print (y,id(y))
输出结果：
10 8791457912128
20 8791457912448
20 8791457912448
10 8791457912128

将多个变量引用到一个值上。
x=y=z=100
print (x,y,z,id(x),id(y),id(z))

3.　　字符串的一些功能

查看字符串长度

x='aaa11111'
print (len(x))

　　  字符串切片

x='abc12345ABC'
print (x[1:9:3])
第一个数字1表示从索引1开始，
第二个数字9表示到第9-1索引结束
第三个数字3表示步长，从索引1开始数，三步一个。

输出的结果：b25

　      成员运算符

x='abc12345ABC'
print ('A' in x)
print ('B' not in x)
输出的结果

True

False

　　 移除空格

使用字符串的函数strip()    lstrip()    rstrip()

strip()默认移除的是空白符，\t  \r \n.

name = " yangjianbo"
print (name)
name=name.strip()
print (name)
输出的yangjianbo，没有前面的空白。

name = "yangjianbo*****"
name=name.strip('*')
print (name)
输出的结果：忽略*号字符。

name = "yangjianbo*****"
name=name.strip('an')
print (name)
输出的结果：我要忽略an，这个an字符在整个字符串的中间部分，而不是两头，结果输出的结果依然是原来的值

结论：中间的字符不能被忽略，只能忽略头和尾的字符。

分割

        x='I am yang jian bo !'

        print (x.split(' ',1))

        输出结果：split函数第一个参数是以哪个分隔符进行切割（默认为空格，\r \n \t），第二个参数是要求分成几份。

        也可以只指定第一个参数，会以最大的份数分割，分割成列表数据类型。

以字符开头

x='I am yang jian bo !'
print (x.startswith('yang',5,11))
输出的结果： True
startswith函数的意思是：是不是以指定的字符串开头的，第一个参数是你要查找的字符串，第二个参数是你要从哪个索引开始查，第三个参数是指你到哪个索引结束。返回的值是布尔值。正确则为true,则为false.

以字符结尾

x='I am yang jian bo !'
print (x.endswith('yang',5,11))
输出结果： False
endswith函数是用来检测是不是以指定的字符串结尾的，参数设置与startswith相同，返回值也是一样的。

　替换

x='I am yang jian bo !'
print (x.replace('a','b',2))
输出的结果：I bm ybng jian bo !
replace函数用来替换指定的字符串，第一个参数指定旧的字符串，第二个参数指定新的字符串，第三个参数指定要替换几个字符串。

 大写改小写

x='I am yang jian bo !'
print (x.upper())
输出的结果：I AM YANG JIAN BO !
将字符串中的小写字母改为大写字母。

将结果改为小写

x='I am yang jian bo !'
print (x.lower())
输出的结果：i am yang jian bo !
将字符串中的大写字母改为小写字母。

查找字符对应的索引

x='I am yang jian bo !'
print (x.index("a"))
输出的结果：将第一个匹配的字符串对应的索引打印出。

判断字符串是不是只包含数字

password=input("输入密码：")
if not password.isdigit() :
     print ("请输入正确密码，只包含数字!")
else:
     print ("登录成功！")
输出的结果：如果输入字母，会报错。

　　 同理is类型的函数还有

string.isalnum()

如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

string.isalpha()

如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False

string.isdecimal()

如果 string 只包含十进制数字则返回 True 否则返回 False.

字符串的join函数

l=['True','or','False']
s=' '
res=s.join(l)
print(res,type(res))
结果:

"D:\Program Files\Python36\python.exe" C:/Users/yangjianbo/PycharmProjects/untitled/第三课函数基础/join函数.py
True or False <class 'str'>

结论：

Python join() 方法用于将列表中的元素以指定的字符连接生成一个新的字符串。

4.　　列表

　　　　长度

x=['yangjianbo','wangyanhe','gaozhongmin']
print (len(x))　
输出结果：　　3

　　　　切片

x=['yangjianbo','wangyanhe','gaozhongmin']
print (x[1:3])
输出的结果：['wangyanhe', 'gaozhongmin']
切片的顺序其实跟步长有关系，默认步长为1。
从列表索引1开始，到索引3（不包括）结束。

x=['yangjianbo','wangyanhe','gaozhongmin','gushuwei','liudehua','zhangxueyou']
print (x[-3:-1])
输出结果：['gushuwei', 'liudehua']
从列表索引-1开始(不包括)，到索引-3（包括）结束。

　　　　翻转

num=[1,2,3,4,5,6,7]
print (num[::-1])
输出结果：[7, 6, 5, 4, 3, 2, 1]

　　　　 追加

x=['yangjianbo','wangyanhe','gaozhongmin']
x.append('gushuwei')
print (x)
输出的结果：['yangjianbo', 'wangyanhe', 'gaozhongmin', 'gushuwei']
append()函数在列表的最后追加一个新的元素，append()函数不会有返回值。返回None

　　　　删除

x=['yangjianbo','wangyanhe','gaozhongmin']
print (x.pop(2))
输出结果：gaozhongmin      
pop()函数的参数是索引
pop删除并返回值

x=['yangjianbo','wangyanhe','gaozhongmin','wang','gaozhongmin']
print (x.remove('gaozhongmin'))
print (x)
输出结果：None
　　　　  ['yangjianbo', 'wangyanhe', 'wang', 'gaozhongmin']
remove()函数的参数是元素的值
remove删除元素，但是不会返回值

　　　　更新

x=['yangjianbo','wangyanhe','gaozhongmin']
x[1]='zhangxueyou'
print (x)
输出结果：['yangjianbo', 'zhangxueyou', 'gaozhongmin']

　　　　排序

　　　　练习题

1. 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量

data=['alex',49,[1900,3,18]]
name=data[0]
age=data[1]
birth=data[2]
print (name,age,birth[0],birth[1],birth[2])
输出结果：alex 49 1900 3 18

2. 用列表模拟队列
   队列要求就是：先进先出，后进后出。

num=[]    先创建一个空的列表
num.append(1)    往空的列表追加一个1
num.append(2)    再追加一个2
num.append(3)    再追加一个3
num.append(4)    再追加一个4
num.pop(0)       删除第一个元素
num.pop(0)       删除第一个元素

num.pop(0)       删除第一个元素

num.pop(0)       删除第一个元素
print (num)
以上就相当于先进先出。

3. 用列表模拟堆栈
   先进后出，后进先出

num=[]
num.append(1)
num.append(2)
num.append(3)
num.append(4)
num.pop(-1)
num.pop(-1)
num.pop(-1)
num.pop(-1)
print (num)

　4. 有如下列表，请按照年龄排序（涉及到匿名函数）

l=[
    {'name':'alex','age':84},
    {'name':'oldboy','age':73},
    {'name':'egon','age':18},
]

五. 元组
    长度
    读取
    切片
    成员运算in或者not in 
    元组与列表相同

六. 字典
    键值要成对。
    键必须为不可变类型，所以键不能为列表。值可以为任意类型。

    读取

xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
print (xitongbu['name'])
输出的结果：yangjianbo
字典查询，需要按照键查找，不能按照索引，因为字典是无序的。

　　   长度

xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
print (len(xitongbu))
输出的结果：3
显示字典有几对键值。

    成员in not in 

xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
print ('name' in xitongbu)
输出的结果：True
字典只能查看键是不是成员，而不能看值。

　　添加键值

xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
print (xitongbu)
输出结果：{'name': 'yangjianbo', 'age': 30, 'zhiwei': 'gongchengshi', 'gongzi': 20000}

　　删除某个键

xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
del xitongbu['zhiwei']
print (xitongbu)
输出结果：{'name': 'yangjianbo', 'age': 30, 'gongzi': 20000}

　　删除整个字典

xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
del xitongbu
print (xitongbu)
输出的结果：NameError: name 'xitongbu' is not defined
删除xitongbu,变量都不存在了。

　　清空整个字典

xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
xitongbu.clear()
print (xitongbu)
输出的结果：{}
字典被清空，但是变量还在。

　　　字典常用的方法

清空   dic.clear()

删除键并返回值  dic.pop()
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
print (xitongbu.pop('gongzi'))
print (xitongbu)
输出的结果：{'name': 'yangjianbo', 'age': 30, 'zhiwei': 'gongchengshi'}
使用pop函数删除键，会有返回值。
打印键  dic.keys()
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
print (xitongbu.keys())
print ('name' in xitongbu.keys())
输出的结果：字典的所有键会被打印出
打印值　　dic.values()
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
print (xitongbu.values(),type(xitongbu.values()))
print ('gongchengshi' in xitongbu.values())
输出的结果：打印出的结果是字典所有的值。

打印键和值   dic.items()
xitongbu={'name':'yangjianbo','age':30,'zhiwei':'gongchengshi'}
xitongbu['gongzi']=20000
print (xitongbu.items(),type(xitongbu.items()))
输出的结果：打印出字典的键和值。

七. 集合
    特点：与字典一样采用大括号，但是只有值，没有键。 集合不支持索引。
    长度 len()函数

name={'yangjianbo','wangyanhe','gaozhongmin'}
print (len(name))    

    成员in not in

name={'yangjianbo','wangyanhe','gaozhongmin'}
if 'yangjian' in name:
       print ("you are right!")
else:
       print("you are wrong!")

    交集  使用符号&

name1={'yangjianbo','wangyanhe','gaozhongmin'}
name2={'yangjianbo','zhoujianping','liushuang'}
print (name1&name2)
输出的结果：是两个集合的相同的部分。

    差集   -

name1={'yangjianbo','wangyanhe','gaozhongmin'}
name2={'yangjianbo','zhoujianping','liushuang'}
print (name1-name2,type(name1-name2))
输出的结果：谁在前面，就以谁为标准，减去相同的，剩下的就是差集。

name1={'yangjianbo','wangyanhe','gaozhongmin'}
name2={'yangjianbo','zhoujianping','liushuang'}
print (name2-name1,type(name2-name1))
输出的结果：顺序不同，最后得到的差集也不同。

    并集   |

name1={'yangjianbo','wangyanhe','gaozhongmin'}
name2={'yangjianbo','zhoujianping','liushuang'}
print (name1|name2)
输出的结果：两个集合合并后的结果，合并后还是一个集合。

    对称差集   ^

name1={'yangjianbo','wangyanhe','gaozhongmin'}
name2={'yangjianbo','zhoujianping','liushuang'}
print (name2^name1,type(name2^name1))
输出的结果：{'gaozhongmin', 'wangyanhe', 'zhoujianping', 'liushuang'} <class 'set'>

八. for循环
    for循环用来遍历string和list，字典的内容。

遍历字符串
name='yangjianbo'
for i in name:
      print (i)
输出的结果：单个的字符.
打印出字符的索引

遍历列表

name=['yangjianbo','wangyanhe','gaozhongmin']
for i in name:
      print (i)
输出的结果：输出各个元素。
          打印出列表的元素。

遍历列表：

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")
输出结果：当循环完成时候，才会执行else后面的语句，但是这个for循环不会执行else语句，因为执行被break.

　　

九. 身份运算符
    is is not 
    is与==的不同：is查看对象是否来自一个引用，==比较的是值。
十.字码编符
   计算机只认识0和1
   把字符翻译成数字。这个翻译过程就叫做字符编码。
   最开始的字符编码表ASCII，一个bytes表示一个字符，一个bytes有8位，可以表示256个字符。ASCII最高一位保留，最初只用了127个字符。后来拉丁文也进入了ASCII编码。
   但是ASCII无法显示中文，于是中国人就发明了GB2312,用两个字节表示中文，也就产生了2的16次方-1个，表示中文。
   日本人发明了自己的字符编码，韩国人也有自己的字符编码，但是各国的字符编码都不能相互读出来，所以产生了乱码。
   于是在这种情况下，为了统一各国的字符编码，就产生了一种unicode，用两个字节表示所有的字符，不管是英文，中文，日文，韩文，都用两个字节来表示。unicode这种方式，
   会导致英文字符，前8位的浪费。
   所以又产生了UTF-8，可变长的字符编码，对英文字符用一个字节，对中文字符用3个字节。
   unicode:简单粗暴，执行速度快，但是浪费空间
   UTF-8:执行速度慢，因为它得检查字符，节约空间。
   当内存从硬盘读取数据的时候，优先考虑的是速度，所以内存内部使用的是unicode.当UTF-8翻译成unicode的时候，叫做：decode，过程叫做解码。
   当内存保存数据到硬盘的时候，优先考虑的是空间，所以硬盘使用的是UTF-8或者其他国家的编码。当unicode翻译成UTF-8的时候，叫做：encode，过程叫做编码。
   存的时候用什么编码，读的时候就用什么编码。

   读文件的阶段：
   python2解释器默认编码是ASCII
   python3解释器默认编码是UTF-8
   所以要在python文件开头，加#coding:指定文件保存时候的编码。

   执行文件的阶段:
   执行python代码的时候，python3的字符串是unicode编码.

x='杨建'
print(type(x.encode('gbk')))
只有unicode才可以encode为其他编码。

   执行python代码的时候，python2的字符串是bytes编码.所以在python2的字符串前面加u.
   x=u'你好'  这样就成为了unicode编码。

   windows终端编码gbk
   linux终端编码utf-8

最后文件练习题：

#求出所购买的东西的价格总数。

count=[]
with open('a.txt','r') as read_f:
       for line in read_f:
            line=line.split(' ')
            line_count=int(line[1])*int(line[2])
            count.append(line_count)
            if len(count)==5:
                 print(sum(count))

作业一：

#作业一: 三级菜单
#要求:
打印省、市、县三级菜单
可返回上一级
可随时退出程序
低级版本：

menu = {
    '北京':{
        '海淀':{
            '五道口':{
                'soho':{},
                '网易':{},
                'google':{}
            },
            '中关村':{
                '爱奇艺':{},
                '汽车之家':{},
                'youku':{},
            },
            '上地':{
                '百度':{},
            },
        },
        '昌平':{
            '沙河':{
                '老男孩':{},
                '北航':{},
            },
            '天通苑':{},
            '回龙观':{},
        },
        '朝阳':{},
        '东城':{},
    },
    '上海':{
        '闵行':{
            "人民广场":{
                '炸鸡店':{}
            }
        },
        '闸北':{
            '火车战':{
                '携程':{}
            }
        },
        '浦东':{},
    },
    '山东':{},
}
while True:
    for key1 in menu:
        print(key1)
    choice1=input('选择>>').strip()
    if choice1=='b':break
    if not choice1 or choice1 not in menu:continue

    while True:
        for key2 in menu[choice1]:
            print(key2)
        choice2=input('选择>>').strip()
        if choice2=='b':break
        if not choice2 or choice2 not in menu[choice1]:continue

        while True:
            for key3 in menu[choice1][choice2]:
                print(key3)
            choice3=input('选择>>').strip()
            if choice3=='b':break
            if not choice3 or choice3 not in menu[choice1][choice2]:continue

            while True:
                for key4 in menu[choice1][choice2][choice3]:
                    print(key4)
                choice4=input('选择>>').strip()
                if choice4=='b':break

升级版本：

menu = {
    '北京':{
        '海淀':{
            '五道口':{
                'soho':{},
                '网易':{},
                'google':{}
            },
            '中关村':{
                '爱奇艺':{},
                '汽车之家':{},
                'youku':{},
            },
            '上地':{
                '百度':{},
            },
        },
        '昌平':{
            '沙河':{
                '老男孩':{},
                '北航':{},
            },
            '天通苑':{},
            '回龙观':{},
        },
        '朝阳':{},
        '东城':{},
    },
    '上海':{
        '闵行':{
            "人民广场":{
                '炸鸡店':{}
            }
        },
        '闸北':{
            '火车战':{
                '携程':{}
            }
        },
        '浦东':{},
    },
    '山东':{},
}
level=[]
while True:
    for key in menu:
        print(key)
    choice=input('选择>>').strip()
    if choice=='b':
        if len(level)==0:break
        menu=level[-1]
        level.pop()
    if not choice:continue
    if choice not in menu:continue
    level.append(menu)
    menu=menu[choice]

作业二最终版：

#作业二：请闭眼写出购物车程序
#需求:
用户名和密码存放于文件中，格式为：egon|egon123
启动程序后，先登录，登录成功则让用户输入工资,然后打印商品列表，失败则重新登录，超过三次则退出程序
允许用户根据商品编号购买商品
用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
可随时退出，退出时，打印已购买商品和余额

最终代码：

dic={
    1:['apple',200],
    2:['tesla',2000000],
    3:['lenovo',3000]
    }
userinfo={'yangjianbo':['123456',20000],'wangyanhe':['abcd',200]}
count=0
while True:
    username = input('用户名>>').strip()
    if count==3:
        print("用户名输入已经3次")
        break
    elif not username in userinfo:
        print("用户名错误")
    elif username in userinfo:
        password = input('密码>>').strip()
        if  password!=userinfo[username][0]:
            print('用户名密码不正确！')
            count+=1
        elif  password==userinfo[username][0]:
            print('登陆成功！')
            while True:
                choice_dic={'购物车':1,'查看余额':2,'退出':3}
                print(choice_dic)
                choice_type=int(input('请输入您的选择：'))
                if choice_type==choice_dic['购物车']:
                    print(dic)
                    while True:
                        choice = input('请输入您要购买的物品的编号>>').strip()
                        if choice=='exit':
                            exit()
                        elif not choice.isdigit(): continue
                        for id, product in dic.items():
                            choice = int(choice)
                            if choice == id:
                                print('确认要购买%s吗？' % product[0])
                                quren = input('是否购买 y/n:').strip()
                                if quren in ('yes' or 'y'):
                                    userinfo[username][1] = int(userinfo[username][1])
                                    if userinfo[username][1] > product[1]:
                                        userinfo[username][1] = userinfo[username][1] - product[1]
                                        print('您已经购买了%s! 您的余额还有%s元!' % (product[0],userinfo[username][1]))
                                    else:
                                        print('您的余额不足，请尽快充值！')
                                elif quren in ('no' or 'n'):
                                        break

                elif choice_type==choice_dic['查看余额']:
                    print('您的余额是%s元' % userinfo[username][1])
                elif choice_type==choice_dic['退出']:
                    exit()