Python元组，列表及字典

1.列表

# 数组:数据类型必须相同; arr = [1,2,3]
# 列表: 可以是不同数据类型的集合

列表的定义

l1 = [1,2,3,4,5]
print(l1,type(l1))

l2 = [1, 4.5, 1+2j, "hello"]

print(l2, type(l2))

列表的特性

# 字符串的特性: 索引, 切片， 连接， 重复， 成员操作符;
students_name = ['harry', 'westos', 'fentiao', 'natasha']

# 1. 索引
# 正向索引
print(students_name[0])
# 反向索引
print(students_name[-1])

# 2. 切片
print(students_name[::-1])

s = "hello xiao mi"   # "mi xiao hello"
print(" ".join(s.split()[::-1]))

# 3. 重复
print(students_name*3)

# 4. 连接
print(students_name + ['Bob', 'Lilei'])

# 5. 成员操作符
print('Bob' in students_name)
print('fentiao' in students_name)

# 6. for循环遍历列表元素
for student in students_name:

    print("学生姓名:%s" %(student))

# 7. 列表里面嵌套列表
goods = [
    ['apple', 2, 100],
    ['banana', 3, 50],
    ['computer', 4000, 13]
]
# 嵌套索引

print(goods[0][0])

列表特性练习_逗号代码

假定有下面这样的列表:
    names = ['fentiao', 'fendai', 'fensi', 'apple']
    输出结果为:'I have fentiao, fendai, fensi and apple.'
考察点:
    切片:
    字符串的join方法:
# ','.join(names)
names = ['fentiao', 'fendai', 'fensi', 'apple']
print("I have " + ",".join(names[:-1]) + ' and ' + names[-1])
# 求列表的长度

# print(len(names))

列表的增加

names = ['fentiao', 'fendai', 'fensi', 'apple']
# append: 追加， 追加元素到列表的最后;
names.append('westos')
print(names)
names.append(['linux', 'R', 'matlab'])
print(names)
# # insert： 添加元素到指定索引的前面;
names.insert(0, 'java')
print(names)
# # extend: 追加多个元素到列表中;
names.extend(['c', 'C++', 'Go'])

print(names)

列表的删除

names = ['fentiao', 'fendai', 'fensi', 'apple', 'fendai']
# remove: 删除指定的值
names.remove('fendai')
print(names)
# names.pop(): pop删除指定索引的值， 默认情况删除最后一个元素;
# a = name.pop(), a就是删除的那个元素;
value = names.pop(0)
print(value)
print(names)
# del删除列表元素
# del names[0]
# del names[-1]
# del names[1:]
# del names[:-1]
# del names
# # clear: 清空列表
# names.clear()

# print(names)

列表的修改

names = ['fentiao', 'fendai', 'fensi', 'apple', 'fendai']
# 通过索引， 重新赋值；
names[0] = 'redhat'
print(names)
# 通过切片重新赋值
names[:2] = ['java', 'C']

print(names)

列表的查看

names = ['fentiao', 'fendai', 'fensi', 'apple', 'fendai', 'A', 'a', 'ab', 'Ab']
# 查看指定元素的索引值;
print(names.index('fentiao'))
print(names.count('fendai'))
# 按照指定的ASCII码进行排序的;
# names.sort()
# print(names)
# 不区大小写进行排序;
names.sort(key=str.lower)
print(names)
# 列表的反转； 类似于li[::-1]
li = [10, 3, 89, 80]
li.reverse()

print(li)

列表方法练习_用户管理系统

用户登陆系统Version2：
   1). 已知多个用户名和密码分别保存在列表中;
   2). 判断用户名是否存在，
           如果登陆的用户不存在，则报错;；
           如果用户存在， 则判断密码是否正确：
                    如果正确， 输出用户登陆成功;
                    如果不正确， 输出登陆失败;
        3). 为防止黑客暴力破解密码， 登陆最多有3次机会;
"""
names = ['root', 'student']
passwds = ['redhat', 'student']
tryCount = 0
while tryCount < 3:
    tryCount += 1
    inuser = input("用户名:")
    # 1.判断用户是否存在？
    if inuser in names:
        # 2. 判断密码是否正确?
        inpasswd = input("密码:")
        # 找出系统存储的inuser用户的密码;
        index = names.index(inuser)   # inuser='root', index=0
        passwd = passwds[index]     # passwd='redhat'
        if inpasswd == passwd:
            print("%s登陆成功!" %(inuser))
            break
    else:
        print("用户名%s不存在" %(inuser))
else:

    print("尝试次数超过3次!")

列表嵌套操作

import pprint
li1 = [
    [1, 2, 3],
    [2, 3, 4],
    [3, 4, 5]
]
li2 = [
    [2, 3, 4],
    [1, 2, 3],
    [1, 2, 3]
]
# numpy,  pandas, matplotlib
result = [
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0]
]
#  i : 0, 1, 2
for i in range(len(li1)):
    # j: 0, 1, 2
    for j in range(len(li1[i])):
        # [0][0], [0][1], [0][2]
        # [1][0]
        result[i][j] = li1[i][j] + li2[i][j]

pprint.pprint(result)

通过列表实现栈的数据结构

a = 1
stack = [1,2,3,4]
# 栈的工作原理: 先进后出
# 入栈；
# 出栈:
# 栈顶元素:
# 栈长度
# 栈是否为空
# 2. 队列的工作原理： x先进先出
# 入队， 出队， 队头， 队尾， 队列长度， 队列是否为空, 显示队列元素
stack = []
info = """
            栈操作
            
        # 1). 入栈； 
        # 2). 出栈:
        # 3). 栈顶元素
        # 4). 栈长度
        # 5). 栈是否为空     
"""
while True:
    print(info)
    choice = input("请输入选择:")
    if choice == '1':
        item = input("入栈元素:")
        stack.append(item)
        print("元素%s入栈成功" %(item))
    elif choice == '2':
        # 出栈先判断栈是否为空;
        if  not stack:
            print("栈为空， 不能出栈")
        else:
            # item是弹出的那个元素；
            item = stack.pop()
            print("元素%s出栈成功" %(item))
    elif choice == '3':
        if len(stack) == 0:
            print("栈为空， 无栈顶元素")
        else:
            print("栈顶元素为%s" %(stack[-1]))
    elif choice == '4':
        print("栈长度为%s" %(len(stack)))
    elif choice == '5':
        if len(stack) == 0:
            print("栈为空")
        else:
            print("栈不为空.")
    elif choice == 'q':
        print("欢迎下次使用!")
        break
    else:

        print("请输入正确的选择!")

栈的应用练习_棒球比赛成绩

你现在是棒球比赛记录员。
给定一个字符串列表，每个字符串可以是以下四种类型之一：
1.整数（一轮的得分）：直接表示您在本轮中获得的积分数。
2. "+"（一轮的得分）：表示本轮获得的得分是前两轮有效 回合得分的总和。
3. "D"（一轮的得分）：表示本轮获得的得分是前一轮有效 回合得分的两倍。
4. "C"（一个操作，这不是一个回合的分数）：表示您获得的最后一个有效 回合的分数是无效的，应该被移除。
每一轮的操作都是永久性的，可能会对前一轮和后一轮产生影响。
你需要返回你在所有回合中得分的总和。
示例 1:
输入: ["5","2","C","D","+"]
输出: 30
解释:
第1轮：你可以得到5分。总和是：5。
第2轮：你可以得到2分。总和是：7。
操作1：第2轮的数据无效。总和是：5。
第3轮：你可以得到10分（第2轮的数据已被删除）。总数是：15。
第4轮：你可以得到5 + 10 = 15分。总数是：30。
示例 2:
输入: ["5","-2","4","C","D","9","+","+"]
输出: 27
解释:
第1轮：你可以得到5分。总和是：5。
第2轮：你可以得到-2分。总数是：3。
第3轮：你可以得到4分。总和是：7。
操作1：第3轮的数据无效。总数是：3。
第4轮：你可以得到-4分（第三轮的数据已被删除）。总和是：-1。
第5轮：你可以得到9分。总数是：8。
第6轮：你可以得到-4 + 9 = 5分。总数是13。
第7轮：你可以得到9 + 5 = 14分。总数是27。
注意：
输入列表的大小将介于1和1000之间。

列表中的每个整数都将介于-30000和30000之间。

判断栈是否为空

stack = []
if stack == []:
    print('NULL')
else:
    print("Not Null")
print(bool([]))
print(bool([1,2,3]))
if stack:
    print(stack)
else:
    print('NULL')
if not stack:

    print('null')

内置方法

print(min([2, 1,2,343,545,6]))
print(max([2, 1,2,343,545,6]))
print(sum([2, 1,2,343,545,6]))
print(sorted([2, 1,2,343,545,6]))
for i in reversed([2, 1,2,343,545,6]):
    print(i,end=',')
print('\n')
for i in zip([1,2,3], ['a','b', 'c']):
    print(i, end=',')
print()
# 枚举， 返回列表的索引及对应的元素值;
for i in enumerate(['a', 'b', 'c']):

    print(i,end=' ')

is和==有何区别

id： 在内存中存储的位置
# type: 变量的；类型
# value： 值是否相等；
# == 判断： type， value
# is: type， value, id
结论:
#   is表示的是对象标识符;表示两个变量的值是否在同一块内存空间;
#   ==表示的是值是否相等;
# 总结: is返回值为True, ==返回一定是True;

a = 'hello'
b = 'hello world'
print(a == b)
c = 18090
d = 18090
print(c==d)

print(id(c), id(d))

深拷贝与浅拷贝

li = [1,2,3,4]
# 拷贝:
# 不是拷贝， 是将li1的指向li的内存位置;
li1 = li
# print(li1 is li)
# 拷贝列表成功
# li2 = li[:]
# print(li2 is li)
# li2.append(5)
# print(li)
# print(li2)
# 浅拷贝
# li = [1, 2, 3, [2, 3]]
# li3 = li[:]
# print(li3 is li)
# print(li3[-1][0] is li[-1][0])
# li3[-1].append(0)
# print(li)

# print(li3)

import copy
li = [1, 2, 3, [2, 3]]
li3 = copy.copy(li)
li.append(1)
# 深拷贝
import copy
li = [1, 2, 3, [2, 3]]
li4 = copy.deepcopy(li)
print(li is li4)
li4[-1].append(0)
print(li)

print(li4)

可变数据类型和不可变数据类型

# 可变数据类型: <有增删改查>列表

# 不可变数据类型: 数值类型都是不可变的;字符串;

2.元组

元组的理解

# 列表: 打了激素的数组;

# 元组: 带了紧箍咒的列表，
names = ['a', 'b', 'c', 1, 1.0, [1, 2]]
tuple_names = (1, 1.0, 2 + 4j, "hello", [1, 2], 10)
print(type(names), type(tuple_names))
# 验证元组的确是不可变的。
# tuple_names[0] = 1
print(tuple_names.index(1))
print(tuple_names.count(1))
# 元组的特性:
# 索引， 切片， 连接， 重复， 成员操作符， for循环
print(tuple_names[0])
print(tuple_names[-1])
print(tuple_names[1:])
print(tuple_names[:-1])
print(tuple_names[::-1])
print(tuple_names + (1,2,43))
# 不同数据类型可以连接么?(除了数值类型之外， 不同数据类型之间不可以连接)
# print([1,2,3]+ (1,2,4))
# print('hello'+[1,2,3])
print(1+2+4j)
print(tuple_names*3)
print(1 in tuple_names)

print(1 not in tuple_names)

元组应用_两变量交换数据

# 元组应用的第一个场景:
x = 1
y = 2
x, y = y, x
# 1. 先把t = (y,x)封装为一个元组， 开辟了一个新的内存空间;
# 2. x = t[0] = 2
# 3. y = t[1] = 1
print(x,y)
# 2. 元组应用的第2个场景:
print("hello %s, hello %s" %("python", "c"))
t = ('python', 'c')

print("hello %s, hello %s" %t)

解压赋值给多个变量

# 元组的赋值
t = ('fentiao', 5, 18)
name, age, weight = t
print(name, weight,age )
li = ['fentiao', 5, 18]
name, age, weight = li

print(name, weight,age )

3.集合

集合数据类型

# 集合元素是不可重复的；
s = {1, 2, 3, 1, 2, 3}
print(s)
# 列表去重;
names = ['hello', 'world', 'hello']
print(list(set(names)))
# 集合的特性： (索引， 切片， 重复， 连接，)===> 不支持， 因为无序;  成员操作符， for循环 ===> 支持;
# 集合是无序的数据类型: 添加元素的顺序和存储的顺序无关;
s = {2,5,8,20}
s
{8, 2, 20, 5}
s.add(6)
s
{2, 5, 6, 8, 20}
# print(s[0])
# print(s[1:])
# print(s*3)
# print(s + {6,7,8})
print(1 in s)
for i  in s:

    print(i, end='')

集合的增删改查

s = {'b', '3', 'a'}
# # 增加单个元素；
# s.add(4)
# print(s)
# # 增加多个元素;
# s.update({4, 5, 6})
# print(s)
# # 删除指定元素
# s.remove(1)
# print(s)
# # 随机删除集合元素
# s.pop()
# print(s)
s.clear()

print(s)

集合操作

# s = {1, 2, 3, 1, 2, 3}
# print(s)
# # 去重
# li = [1, 2, 3, 1, 2, 3]
# print(list(set(li)))
# s1 = {1, 2, 3}
# s2 = {1, 2, 4}
# print("并集:", s1.union(s2))
# print("交集：", s1.intersection(s2))
# # 求交集时， 把s1的值更新为交集的值;
# s1.intersection_update(s2)
# print(s1)
# print(s1.difference(s2))    # s1-instersection(s1,s2)
# print(s2.difference(s1))    # s2-intersection(s1,s2)
# # 求差集时， 把s2的值更新为差集的值;
# print(s2.difference_update(s1))    # s2-union(s1,s2)
# print(s2)
# s1 = {1, 2, 3}
# s2 = {1, 2, 4}
# # 对等差分;
# print(s1.symmetric_difference(s2))
# print(s1 | s2)
# print(s1 & s2)
# print(s1 - s2)
# print(s2 - s1)
# math = ['name1', 'name2']
# english = ['name1']
s1 = {1, 2, 3}
s2 = {1, 2, 4}
# s1是s2的子集？
print(s1.issubset(s2))
# s1是s2的父集？
print(s1.issuperset(s2))
# s1和s2没有交集么? 如果没有交集True，否则返回False;

print(s1.isdisjoint(s2))

集合练习_华为机试题

(华为机试题)题目描述
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，
他先用计算机生成了N个1到1000之间的随机整数（N≤1000）, N是用户输入的，对于
其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应
着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺
序去找同学做调查。请你协助明明完成“去重”与“排序”的工作;
count: 100
1, 4, 34,
# 在1-1000之间随机生成10个数字
random.sample(range(1,1000), 10)
sorted()

li.sort()

import random
# print(random.sample(range(1,1000), 10))
# print(random.randint(1,1000))
# 将input接收的str，清值转化为int类型;
N = int(input("N："))
# list, set, tuple(x)
# 定义空集合时， 不能为s={}, 应该是s = set()
s = set()
for i in range(N):   # 4, (0,1,2,3)
    num = random.randint(1,1000)
    # 将随机生成的数加入到集合中;
    s.add(num)
# 对集合进行排序;

print(sorted(s))

集合练习

1. 共同好友；
        你的好友A,B,C 他的好友C,B,D， 求共同好友：
2.   微信群提醒：
        XXX与群里其他人都不是微信朋友关系
s1, s2, s3
s1 = {s4, s5, s6}
s2 = {s1, s3, s6}
      s3 in (s1 | s2)
3. 权限判断：
        有一个API，要求同时具备A,B,C权限才能访问，目前用户权限为B,C,D，判断该用
户能否访问该API；
实质看用户权限是否为ABC的父集；
ABC     ABCD
ABC     ADF
4. 集合练习:
               随机产生2组各个数字的列表，每组10个数字，如下要求：
                    每个数字取值范围[10,20]
                    统计20个数字中，一共有多少个不同的数字？  # {1,2,3} {2,3,4} # 并集
                    2组中，不重复的数字有几个？分别是什么？{1,2,3} {1,2,4}  # 对等差分;
                    2组中，重复的数字有几个？分别是什么？
5. 一个总任务列表，储存所有任务，一个完成的任务列表。找出未完成的任务; # 实质上是求差集的。
all_task = ['task1', 'task2', 'task3']
complete = ['task1']

import random
li1 = []
li2  = []
for i in range(10):
    li1.append(random.randint(10,20))
    li2.append(random.randint(10,20))
print(li1, li2)

s1 = set(li1)
s2 = set(li2)
print("20个数字中共有%s个不同的数字" %(len(s1 | s2)))
sy_set = s1.symmetric_difference(s2)
print(" 2组中，不重复的数字有%s个， 分别是%s" %(len(sy_set), sy_set))

inster_set = s1 & s2

print("2组中，重复的数字有%s个,分别是%s" %(len(inster_set), inster_set))

4.字典

字典_创建

# 定义空集合， 必须set(),
# {}默认的类型为字典;
d = {}
print(type(d))
# 字典: key-value值, 键值对；
# value值可以是任意数据类型: int,float,long, complex, list, tuple,set, dict
d = {
    '王旭': [18, '男', "请假"],
    '张龙': [18, '男', '俯卧撑']
}
print(d['张龙'])
d2 = {
    'a': 1,
    'b': 2
}
print(d2)
d3 = {
    'a': {1, 2, 3},
    'b': {2, 3, 4}
}
print(d3)
# 字典的嵌套;
students = {
    '13021001': {
        'name':'张龙',
        'age':18,
        'score':100
    },
    '13021003': {
        'name': '张',
        'age': 18,
        'score': 90
    }
}
print(students['13021003']['name'])
# 工厂函数;
l = list([1,2,3])
print(l)
d5 = dict(a=1, b=2)
print(d5)
#
cardinfo = {
    '001':'000000',
    '002':'000000'
}
# fromkeys第一个参数可以列表/tuple/str/set， 将列表的每一个元素作为字典的key值，
#  并且所有key的value值一致， 都为'000000';
print({}.fromkeys({'1', '2'}, '000000'))
# 字典必须是不可变数据类型;d = {[1,2,3]:1}(x)
# 可变数据类型:list, set,  dict

# 不可变: 数值类型， str, tuple

字典的特性

# 索引， 切片， 重复， 连接，成员操作符, for
# set不支持 索引， 切片， 重复， 连接，， 因为set是无序的；
# 1. 判断字典是否是无序的?
# python2中字典加入顺序和存储顺序不一致；
# python3中字典加入顺序和存储顺序一致；
d = {
    '1': 'a',
    '8': 'b'
}
# print(d['1'])
# 字典是不支持索引的；
# print(d[0])
# 字典是不支持切片的；
# print(d[::])
# 字典的重复和连接无意义, 字典的key值是唯一的;
# print(d*3)
# 成员操作符;判断的是某个值是否为字典的key；
# print('1' in d)
# print('1' not in d)
# 字典for循环时， 默认遍历字典的key值;
for key in d:
    print(key)
# 遍历字典:
for key in d:

    print(key, d[key])

字典的增加

services = {
    "http":80,
    'ftp': 21,
    'ssh':22
}
# # 1. 增加一个元素;
#   1). 如果key值存在， 则更新对应的value值;
#   2). 如果key值不存在， 则添加对应的key-value值
# services['mysql'] = 3306
# print(services)
# services['http'] = 443
# print(services）
# 2. 添加多个key-value值；
#   1). 如果key值存在， 则更新对应的value值;
#   2). 如果key值不存在， 则添加对应的key-value值
# service_backup = {
#     'https':443,
#     'tomcat':8080,
#     'http':8080
# }
# services.update(service_backup)
# print(services)
# services.update(flask=9000, http=8080)
# print(services)
print(services)
# 3.setdefault添加key值;
#   1). 如果key值存在， 则不做修改;
#   2). 如果key值不存在， 则添加对应的key-value值
services.setdefault('http',9090)
print(services）
services.setdefault('oracle',44575)

print(services)

字典的删除

services = {
    "http":80,
    'ftp': 21,
    'ssh':22,
    'mysql':3306
}
# 1.
# del services['http']
# print(services)
# 2. pop删除指定key的key-value对,
#   1). 如果key存在, 删除， 并且返回删除key对应的value值;
#   2). 如果key不存在, 直接报错
# item = services.pop('http')
# print(item)
# print(services)
# item = services.pop('https')
# print(item)
# print(services)
#3. popitem删除最后一个key-value值;
item = services.popitem()
print("删除的key-value对是:", item)
print(services)
# 4. 清空字典内容;
services.clear()

print(services)

字典的查看

services = {
    "http":80,
    'ftp': 21,
    'ssh':22,
    'mysql':3306
}
# 查看字典的key值;
print(services.keys())
# 查看字典的value值;
print(services.values())
# 查看字典的(key,value)值;
print(services.items())
# 1. 查看key的value值；key不存在，则报错;
print(services['http'])
# print(services['https'])
# 2. 查看key的value值；
#       key不存在, 默认返回None；
#       key不存在， 有default值， 则返回default值;
print(services.get('http'))
print(services.get('https'))

print(services.get('https', 443))