python-study-06

元组

一：基本使用
1 用途：元组是不可变的列表，能存多个值，但多个值只有取的需求，而没有改的需求，那么用元组合最合理

2 定义方式:在()内用逗号分割开，可以存放任意类型的值
names=('alex','egon','wxx') #names=tuple(('alex','egon','wxx'))
print(type(names))
强调: 当元组内只有一个元素时，务必记住加一个逗号
x=('egon',)
print(type(x))

3 常用操作+内置的方法
1、按索引取值(正向取+反向取)：只能取
names=('alex','egon','wxx')
names[0]='sb'

2、切片(顾头不顾尾，步长)
names=('alex','egon','wxx','lxx','cxxx')
print(names[1:3])

3、长度
names=('alex','egon','wxx','lxx','cxxx')
print(len(names))
4、成员运算in和not in
names=('alex','egon','wxx','lxx','cxxx')
print('alex' in names)

5、循环
names=('alex','egon','wxx','lxx','cxxx')
for item in names:
    print(item)


二：该类型总结
1 存一个值or存多个值
可以存多个值，值都可以是任意数据类型

2 有序or无序（按索引取值）
有序
3 可变or不可变
不可变
names=('alex','egon','wxx','lxx','cxxx','lxx')
del names[0]
names[0]='sb'
print(names.count('lxx'))
print(names.index('wxx',0,3))

names=('alex','egon','wxx','lxx','cxxx','lxx')
names=1
l=[1,243,3]
l=3333
l=['a','b','c']
print(id(l))
print(id(l[0]))
l[0]='A'
print(id(l[0]))
print(id(l))

names=('a','b','c')

列表可变的底层原理：
指的是索引所对应的值的内存地址是可以改变的

元组不可变的底层原理：
指的是索引所对应的值的内存地址是不可以改变的
或者反过来说，只要索引对应值的内存地址没有改变，那么元组始终是没有改变的

t1=(['a','b','c'],'wc','office')

print(id(t1[0]))
print(id(t1[1]))
print(id(t1[2]))

t1[0][0]='AAAA'
print(t1)

print(id(t1[0]))

简单购物车,要求如下：
实现打印商品详细信息，用户输入商品名和购买个数，
则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}

shopping_cart=[]
while True:
    for k in msg_dic:
        info='商品名：%s 价钱：%s' % (k, msg_dic[k])
        print(info.center(50,' '))
    name=input('请输入商品名>>: ').strip()
    if name not in msg_dic:
        # 输入的商品名不合法，打印提示信息并且直接进入下一次循环
        print('输了些什么玩儿。。。重输')
        continue
    # else:
    #     #输入的商品品合法，结束循环
    #     break

    while True:
        count=input('请输入购买个数：').strip()
        if count.isdigit():
            #输入个数合法
            count=int(count)
            break
        else:
            print('商品的个数必须为整数')
            # continue # 不加continue也会跳入下一次

    # name,count
    for item in shopping_cart:
        # print(item)
        if name == item['name']:
            item['count']+=count
            break
    else:
        price=msg_dic[name]
        info={'name':name,'count':count,'price':price}
        shopping_cart.append(info)
    print(shopping_cart)

字典

一：基本使用
1 用途：用来存多个值，但每一个值都有一个key与之对应，key对值有描述性的功能
       当存储多个值表示的不同的状态时，

2 定义方式:{}内用逗号分隔开多个元素，每一个元素都是key：value的形式
value可以是任意数据类型，但是key必须为不可变类型(值变id就变称为不可变类型)，key通常应该是字符串类型，
d={'x':1,'y':2} #d=dict({'x':1,'y':2})
d=dict(a=1,b=2,c=3)
print(d)

dic={1:'a',0:'b',1.1:'c',(1,2,3):'d'}
print(dic[1])
print(dic[0])
print(dic[1.1])
print(dic[(1,2,3)])
dic={[1,2,3]:'a'}  #字典的key只能是不可变数据类型
dic={{'x':1}:'a'}   #字典本身是可变数据类型（即值变id不变）

3 常用操作+内置的方法
优先掌握的操作：
1、按key存取值：可存可取，
d={'x':1,'y':2}
d['x']=100  #可以修改值，值变id不变
print(d)
d['z']=3     #可增加值，列表没法这样增加，只能用append
print(d)

l=['a','b']  #列表
l[2]='c'

2、长度len
d={'x':1,'y':2}
print(len(d))
3、成员运算in和not in  针对key来说的
d={'x':1,'y':2}
print('x' in d)

4、删除
d={'x':1,'y':2}
del d['x']      #通用删除，无返回值
print(d)
res=d.pop('y')  #字典特有删除，返回对应key的值
print(d)
print(res)

res=d.popitem()   #随机删除，返回元组
print(d)
print(res)

d={'a':1,'b':2,'c':3,'d':4}
for k in d:
    print(k)

l=[1,2,3]
del l[1]
print(l)

5、键keys()，值values()，键值对items()
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
names=[]
for k in msg_dic:
    names.append(k)
print(names)
values=[]
for k in msg_dic:
    values.append(msg_dic[k])
print(values)

keys=msg_dic.keys()
print(keys)
for k in keys:
    print(k)

l=list(keys)
print(l)

vals=msg_dic.values()
print(vals)
print(list(vals))

print(msg_dic.items())
print(list(msg_dic.items()))
6、循环
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
只取key
for k in msg_dic:
    print(k,msg_dic[k])

for k in msg_dic.keys():
    print(k,msg_dic[k])

只取value
for v in msg_dic.values():
    print(v)

取key和value
for k,v in msg_dic.items(): #k,v=('apple', 10)
    print(k,v)

需要掌握的内置方法（****）
d={'x':1,'y':2,'z':3}
v=d.get('xxxx')
print(v)
print(d['xxxxxxx'])

d={'x':1,'y':2,'z':3}
d1={'a':1,'x':1111111}
d.update(d1)
print(d)

#初始化字典
l=['name','age','sex']
d={}
for k in l:
    d[k]=None
d=dict.fromkeys(l,None)
print(d)

info.setdefault
info={'name':'egon','age':18,'sex':'male'}

如果字典中有setdefault指定的key，那么不改该key对应的值，返回原的value
res=info.setdefault('name','EGON_NB')
print(info)
print(res)

如果字典中没有setdefault指定的key，那么增加一个key:value,返回新的value
info.setdefault('height',1.80)
print(info)

info={'age':18,'sex':'male'}
v=info.setdefault('name','浩哥')
print(v)

s='hello alex alex say hello sb sb'
l=s.split()
print(l)
d={}
for word in l: #word=  'hello'
    if word not in d:
        d[word]=1 #{'hello':2, 'alex':2,'say':1}
    else:
        d[word]+=1
print(d)

s='hello alex alex say hello sb sb'
l=s.split()
print(l)
d={}

d={'hello':2,'alex':2}
for word in l: #word='alex'
    # d[word]=l.count(word) #d['alex']=2
    d.setdefault(word,l.count(word))

print(d)

#二：该类型总结
1 存一个值or存多个值
    可以存多个值，值都可以是任意类型，而key必须是不可变类型，通常应该是不可变类型中字符串类型

2 有序or无序
无序

3 可变or不可变

d={'x':1,'y':2}
print(id(d))
d['x']=1111
print(id(d))

d=123

今日作业

1. 实现打印商品详细信息，用户输入商品名和购买个数，
则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
} 

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}

shopping_cart = []
while True:
    for k in msg_dic:
        info = '商品名：%s 价钱：%s' % (k, msg_dic[k])
        print(info.center(50,' '))
    name=input('请输入商品名>>: ').strip()
    if name not in msg_dic:
        print('商品名错误，重新输入')
        continue

    while True:
        count=input('请输入购买个数: ').strip()
        if count.isdigit():
            count=int(count)
            break
        else:
            print('商品的个数必须为整数')

    for item in shopping_cart:
        if name == item['name']:
            item['count']+=count
            break
    else:
        price=msg_dic[name]
        info={'name':name,'count':count,'price':price}
        shopping_cart.append(info)
    print(shopping_cart)

2. 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中

即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

l=[11,22,33,44,55,66,77,88,99,90]
l1=[]
l2=[]
for i in l:
    if i >= 66:
        l1.append(i)
    else:
        l2.append(i)
d={'k1':l1,'k2':l2}
print(d)

3. 统计s='hello alex alex say hello sb sb'中每个单词的个数

结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}

s='hello alex alex say hello sb sb'
l=s.split()
d={}
for word in l:
    d[word] = l.count(word)
    d.setdefault(word, l.count(word))
print(d)

4. 有如下列表，请采用两种方式取出列表中的值
   my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
   方式一：依赖索引，请写出while循环与for循环两种实现方式
   方式二：不依赖索引

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
count = 0
while count < len(my_girl_friends):
    print(my_girl_friends[count])
    count += 1

my_girl_friends = ['alex', 'wupeiqi', 'yuanhao', 4, 5]
for i in range(len(my_girl_friends)):
    print(my_girl_friends[i])

my_girl_friends = ['alex', 'wupeiqi', 'yuanhao', 4, 5]
for i in my_girl_friends:
    print(i)

预习

集合 文件处理 字符编码
http://www.cnblogs.com/linhaifeng/articles/7133357.html

数据类型的内置操作表