基本数据类型

一、基本数据类型

列表

#! /usr/bin/enc python
# -*- coding:utf-8 -*-

# 列表
name_list = ['alex', 'wenzm', 'eric']

# 索引
print(name_list[0])    # 打印索引为0的元素
print(name_list[2:len(name_list)])    # 打印索引>=2 小于序列长度的元素

# 列表提供的房法
# append():在列表元素末尾追加
name_list.append('James')
# count():返回某一元素在列表中出现的次数
name_list.count('alex')
# extend():扩展，逐一追加
temp = ['first', 'second']
name_list.extend(temp)
# index():索引
name_list.index('alex')    # 返回元素的索引值
# insert():插入
name_list.insert(1, 'sb')    # 在索引为1的位置插入元素
# pop():移除掉末尾元素并返回
a = name_list.pop()    #移除掉末尾元素并赋值给了a变量
# remove():移除某元素，如果有多个只移除从左到右找到的第一个
name_list.remove('wenzm')    # 移除指定元素
# reverse():倒叙（翻转）
name_list.reverse()
# sort():排序
name_list.sort()

元组

#! /usr/bin/env python
# -*- coding:utf-8 -*-

# 元组
name_tuple = ('alex', 'eric')
# 索引
print(name_tuple[0])    #打印第0个索引位置的元素
# len():长度
print(len(name_tuple))    # 打印元组的长度
# 切片
print(name_tuple[0:1])    # 打印第0到第一个元素
# 循环取
for i in name_tuple:
    print(i)
# 元组不能删除
# count():返回元素出现的个数
print(name_tuple.count('alex'))
# index():返回元素的索引位置
print(name_tuple.index('alex'))

字典

#! /usr/bin/env python 
# -*- coding:utf-8 -*-

user_info = {
    'name':'alex',
    'age':33,
    'gender':'M'
}

# 字典内置的功能
# 索引
print(user_info['name'])    #获取字典指定的key对应的value
# 切片：字典没有办法切片，因为key不是连续的
# 循环
for key in user_info:
    print(key)      # 默认输出了所有的键

for value in user_info.values():
    print(value)    # 循环打印所有的值
print(user_info.keys())    #打印所有的键key
print(user_info.values())   #打印所有的值value
print(user_info.items())    # 打印所有的键值对

for key, value in user_info.items():
    print(key, value)       # 打印所有的键值对

# clear(): 清除所有内容
#print(user_info.clear())

# get():根据key获取值，存在则返回对应value，如果key不存在，返回none
print(user_info.get('name'))
print(user_info['name'])    # 通过索引key取，如果不存在会报错，推荐使用get()

# has_key():检查字典中指定的key知否存在 python3以后没有此方法
#print(user_info.has_key('name'))
print('name' in user_info.keys())

# pop():移除指定key的键值对并将他返回
# a = user_info.pop('name')
# print(a)
# print(user_info)

# popitem():移除字典末尾的键值对并返回
print(user_info)
a = user_info.popitem()
print(a)
print(user_info)

# update():批量更新，可以吧新的字典在后面追加到云字典中
print(user_info)
test = {
    'a':123,
    'b':456,
}
user_info.update(test)
print(user_info)

# 删除指定索引的键值对
del test['a']
print(test)

其他

enumerate()自动生成一列，从0开始自增1

#! /usr/bin/env python 
# -*- coding:utf-8 -*-

enumerate() 给列表自动生成一列，默认从0开始，自增1，如果有指定参数，则从给的参数开始
sop_li = ['电脑','鼠标','显示器','电源','飞机']
for index, item in enumerate(sop_li, 1):
    print(index, item)
inp = int(input('请输入商品：'))  # int()转换成数字
print(sop_li[inp-1])

#range,xrange
#range:用来获取指定范围内的数。range(0,10000)
#py2.7
# for i in xrange(1, 1000):
#     print(i)
# py3+
for i in range(1, 10):
    print(i)

for i in range(10, 1, -1):
    print(i)
li = ['alex', 'eric']
print(li)
for i in range(len(li)):
    print(i, li[i])

 练习题：

一、元素分类

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

#! /usr/bin/env python
# -*- coding:utf-8 -*-

a = {
    'k1':[],    # 创建列表用于存储多个数
    'k2':[],
}

li1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
for i in li1:
    if i > 66:
        a['k1'].append(i)
    else:
        a['k2'].append(i)

print(a)

 

二、查找

查找列表中元素，移除每个元素的空格，并查找以 a或A开头 并且以 c 结尾的所有元素。

    li = ["alec", " aric", "Alex", "Tony", "rain"]

    tu = ("alec", " aric", "Alex", "Tony", "rain") 

    dic = {'k1': "alex", 'k2': ' aric',  "k3": "Alex", "k4": "Tony"}

 

#! /usr/bin/env python
# -*- coding:utf-8 -*-

li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
for i in li:
    print(i.strip())
    # 先转换为大写
    if i.capitalize().startswith('a') and i.endswith('c'):
        print(i)

for i in tu:
    # print(i.strip())
    if i.startswith('a') or i.startswith('A') and i.endswith('c'):
        print(i)
for k, v in dic.items():
    print(v.strip())
    if v.startswith('a') or v.startswith('A') and v.endswith('c'):
        print(v)

 

 

三、输出商品列表，用户输入序号，显示用户选中的商品

    商品 li = ["手机", "电脑", '鼠标垫', '游艇']

 

#! /usr/bin/env python
# -*- coding:utf-8 -*-

li = ["手机", "电脑", '鼠标垫', '游艇']

li2 = ["手机", "电脑", '鼠标垫', '游艇']
for index, item in enumerate(li2, 1):
    print(index, item)
inp = int(input("请选择商品："))
print(li2[inp-1])

 

四、购物车

功能要求：

• 要求用户输入总资产，例如：2000
• 显示商品列表，让用户根据序号选择商品，加入购物车
• 购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。
• 附加：可充值、某商品移除购物车

• #! /usr/bin/env python
  # -*- coding:utf-8 -*-
  
  shopp = []
  money = int(input("请输入资产："))
  cost = 0
  active = True
  while active:
      for index, item in enumerate(goods, 1):
          print(index, item)
      inp = input("请选择商品q退出：")
      if inp == 'q':
          active = False
      else:
          inp = int(inp)
          if money > int(goods[inp-1]['price']):
              shopp.append(goods[inp-1])
              money -= goods[inp-1]['price']
              cost += goods[inp-1]['price']
              print("购买了{}".format(goods[inp - 1]))
          else:
              print("只剩${}！".format(money))
              active = False
  
  print("共花费${}".format(cost))
  print("已买到商品如下：".center(20, '-'))
  for index, item in enumerate(shopp, 1):
      print(index, item['name'])
  print("还剩${}".format(money))

  五、用户交互，显示省市县三级联动的选择

  dic = {
      "河北": {
          "石家庄": ["鹿泉", "藁城", "元氏"],
          "邯郸": ["永年", "涉县", "磁县"],
      }
      "河南": {
          ...
      }
      "山西": {
          ...
      }
   
  }
  
  while True:
      for key in dic:
          print(key)
      inp = input("请输入省任意键返回上一层：")
      if inp in dic:
          while True:
              for i in dic[inp]:
                  print('\t',i)
              inp1 = input("请输入市任意键返回上一层：")
              if inp1 in dic[inp]:
                  while True:
                      for i in dic[inp][inp1]:
                          print('\t\t', i)
                      inp2 = input("最后一层，按q返回上一层：")
                      if inp2 == 'q':
                          break
              else:
                  break
      else:
          break

 

六、str和bytes

 

str和bytes之间的转换

#! /use/bin/env python
# -*- coding:utf-8 -*-

name = '李璐'
for i in name:
    print(i)
# python3+循环的时候是循环每一个字符
# 字符 —> 字节 byte_list = bytes('字符串', encoding = 'utf-8') 返回的是字节，默认每个字节都是16进制表示
# 循环 改字节是用10进制进行循环
# bytes('字符串')
# utf-8 一个字符是三个字节，一个字节是8位
# gbk 一个字符是两个字节


# 转换成bytes
name_by = bytes(name, encoding = 'utf-8')    # 编码格式为utf-8
print(name_by)
name_by1 = bytes(name, encoding = 'gbk')

# 转换成str
# 同样的bytes类型转换成str,注意转换的时候编码格式一定要准确
new_name = str(name_by, encoding = 'utf-8')
print(new_name)
new_name1 = str(name_by, encoding = 'gbk')    # 此时会报编码格式不正确，因为name_by是用utf-8转换的
print(new_name1)
new_name2 = str(name_by1, encoding = 'gbk')
print(new_name2)

"""
什么时候用str()什么时候用bytes?
s = str()   要么是创建字符串，要么是转换成字符串，字节转换成字符串时要知道字节编码格式
b = bytes() 同样要么创建字节，要么是转换成字节，转换的时候同样要知道字符串的编码格式
"""

列表，列表嵌套

#! /usr/bin/env python
# -*- coding:utf-8 -*-

# 列表
# list
#     list()
#     list 类__init__

"""
str() ->创建字符串，或将其他的转换成字符串
-------------------------------------
str() ->创建列表，或将其他的转换成列表
1、创建
li = [12,34,5,21,123]
li1 = list()
li1 = list([12,34,5,21,123])
2、转换
for 循环，字符可迭代
s = '李璐'
li = list(s)    # for循环，将循环每一个元素，当做列表的元素在列表中生成 ['李','璐']
t = ('james', 'haeden', 'alex')
new_t = list(t)
dic = {'k1':'alex','k2':'james'}
li3 = list(dic)
li4 = list(dic.)
print(li3)
"""
dic = {'k1':'alex','k2':'james'}
li3 = list(dic)
li4 = list(dic.items())
print(li3)
print(li4)
# li3.append()  追加
# li3.clear() 清除
# li3.extend()    扩展本身，用另外一个可迭代的对象扩充到末尾
s = '李璐'
li = [11,33,22]
li.extend(s)    # 将s中的每个元素扩充到li末尾
print(li)
# li3.reverse()  反转，内部元素反转
# li3.insert()  向指定索引位置插入元素
li.insert(1,'X')
print(li)


# c.公共功能
li = ['alex', 'eric', 'james', '123']
# 索引
print(li[2])
print(type(li[2]))  # 取得类型为字符串
# 切片
print(li[2:3])
print(type(li[2:3]))    # 原本是什么类型，就是什么类型
# for
# len()



# 列表嵌套
l = ['alex', 'eroc', {
    'k1':'v1',
    'k2':{
        'kk1':'123',
        'kk2':(11,22,33)
    }
}]
#列表嵌套找到11
print(l[2]) #{'k1': 'v1', 'k2': {'kk1': '123', 'k2': (11, 22, 33)}}
print(l[2]['k2'])   #{'kk1': '123', 'k2': (11, 22, 33)}
print(l[2]['k2']['kk2'])    #(11, 22, 33)
print(l[2]['k2']['kk2'][0])    #11

元组、字典嵌套

#! /usr/bin/env python
# -*- coding:utf-8 -*-

# 元组
#   a.创建和转换
#   t = (11,22,33)
#   t = tuple((11,22,33))
#   t = tuple([])   字符串、列表、字典
#   b.特有方法
#    count() index()
#   c.嵌套（元素不可修改）
#   d.元组的特性，不可修改，谁不可修改元组的元素不可被修改,但是元素里面的元素可以被修改
t = ('alex', 'eric', ['james', {'k1':'v1'}])
print(t)
t[2].append('wzm')
print(t)
t[2][1]['k2'] = 123
print(t)
t[2][1].update({'k3':'234'})
print(t)

#   一般的，字符串执行一个功能，会生成一个新的对象，并在内存中保存，自身不变
#          列表、元组、字典执行一个功能，自身会发生变化

#字典
#   1.创建
a = {'k1':'v1', 'k2':'v2'}
a1 = dict(k1 = 123, k2 = 234)
print(a)
print(a)
#   2.列表转换字典
li = [11,22,33]
new_dic = dict(enumerate(li, 1))   # enumerate()自动新增了索引列，并自增1
print(new_dic)
#   3.字典内部功能
# keys()
# valus()
# items()
# pop()
# popitem()
# get()
# fromkeys()
n = new_dic.fromkeys([1,2], 'wzm')  # 创建了两个字典的key为1,2值都是wzm
print(n)
n1 = dict.fromkeys(['k1', 'k2', 'k3'],[])   # 此时创建的是同一个列表
print(n1)
n1['k1'].append('x')    # append(),k1,k2,k3都会添加
print(n1)

 

set
1、创建
s = set()
s = {11,22,33,44}
2、转换
l = '123'
l = (1,2,3)
l = [1,2,3]
s = set(l)
s = set([1,2,3])
s = set((1,2,3))

3、set提供的方法
add()

clear()

difference()
l = [1,2,3,4,1,1,5]
l2 = (1,2,3,8,7)
s = set(l)
s1 = set(l2)
s3 = set()
s4 = set()
s3 = s.difference(s1) # 找s中存在s1中不存在的集合并返回
s4 = s1.difference(s) # 找s1中存在s中不存在的集合并返回

difference_update()
s.difference_update(s1) # 找s中存在s1中不存在的集合并更新自己

 

#! /usr/bin/env python
# -*- coding:utf-8 -*-


# 数据库中原有
old_dict = {
    "#1": {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80},
    "#2": {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80},
    "#3": {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80},
}

# cmdb 新汇报的数据
new_dict = {
    "#1": {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 800},
    "#3": {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80},
    "#4": {'hostname': 'c2', 'cpu_count': 2, 'mem_capicity': 80},
}
需要删除：？
　　需要新建：？
　　需要更新：？ 
　　注意：无需考虑内部元素是否改变，只要原来存在，新汇报也存在，就是需要更新
old_keys = old_dict.keys()
new_keys = new_dict.keys()
# print(old_keys)
# print(new_keys)
old_set = set(old_keys)
new_set = set(new_keys)
# print(old_set)
# print(new_set)
update_set = old_set.intersection(new_set)
del_set = old_set.difference(new_set)
# print(update_set)
# print(del_set)
# for key in update_set:
#     old_dict.
# print(old_dict)
update_dict = {}
for key in update_set:
    update_dict= new_dict[key]

print(update_dict)
print(old_dict)

old_dict.update(update_dict)
print(old_dict)