python的基础语法、三大流程控制、内置数据结构字符串、列表和元组和字典与集合

0.常用操作

#选中内容 ctrl + / 快速注释代码的快捷键
#批量缩进的快捷键： 选中内容 tab
#批量取消缩进 选中 shift+ tab

1.认识变量

1.变量是内存中的一块区域。对象赋值实际上是对象的引用。a=10
2.变量的命名: 变量名由字母，数字，下划线组成, 不能以数字开头. (a,b, c)
hello = 100, hello_world = 100, count2 =100, (1count=10)（错误）
3.Python中，变量定义时不需要指定类型的，当用变量的时候，必须要给这个变量赋值

1.1变量

符号 含义

%s 字符串
%e 对数字进行科学计数法表示
%f 浮点型（%.2f表示显示小数点后两位）
%i 整型

1.2python常见的数据类型

python支持的五种基本数字类型:

类型 类型
int 有符号整数
long 长整数
bool 布尔值 真 或者 假
float 浮点数
complex 复数

1.3认识运算符

整数一般以十进制表示,但是 Python也支持八进制(0开始)或十六进制(0x开始)来表示整数。

十进制转换成二进制 bin(10)
十进制转换成八进制 oct(10)
十进制转换成十六进制 hex(10)

整数的范围取决于机器是32位还是64位? 但长整数不是， 取决于虚拟内存的大小.

主要的运算符有：

1). 算术运算符：+，-，*，**， /， %， //

2). 赋值运算符：=, +=, -=, /=, *=, %=

3). 关系运算符: >, >=, <, <=, !=, ==

逻辑运算符:逻辑与and， 逻辑或or， 逻辑非not

1.4数据的输入和输出

例如：
学生平均成绩统计
编写一个程序，录入学生的姓名和三门科目的百分制成绩，计算该学生的总分和平均成绩。
输入姓名：张三
输入语文成绩：98
输入数学成绩：99
输入英语成绩：97

学生张三的总分为：294，平均成绩为98分。

name = input("输入姓名：")
Chinese = float(input("输入语文成绩："))
maths = float(input("输入数学成绩："))
English = float(input("输入英语成绩："))
sum = Chinese + maths + English
avg = sum / 3
print ("学生{name}的总分为:{sum}.平均成绩为:{avg})

实例2：温度转换器
编写一个程序，将温度从华氏温度转换为摄氏温度。
转换公式: celsius * 1.8 = fahrenheit - 32。
输入华氏温度: 30
输出: 30.0华氏度转为摄氏度为-1.1。

huashi = float(input("输入华氏温度："))
celsius = float ((huashi - 32) / 1.8)
print ("%.2f华氏度转为摄氏度为 %.2f"  %(huashi,celsius))

2.三大流程控制

在python中的三大流程控制：
分别为顺序流程，分支流程，循环流程！
我们分别介绍一下三个流程：

2.1顺序流程控制

会出现判断语句：if else进行接下来的操作！

2.1.分支流程语句

例：

score = int(input("输入分数："))
if score >= 80:
	print('优秀！')
else:
	print('不优秀！')

2.1.1三元运算符

简化我们所写的代码
比如：上面写的代码，就可以写在一行里：

score = int(input("请输入score： "))
print("优秀"if score > 80 else "不优秀！")

2.1.2.多分支流程

需要不止一个判断才能完成的程序！

例如：
需求：
1)如果分数在90<=score<=100,grade=A
2)如果分数在80=<score=<90,grade=B
3)如果分数在score<80,grade=C

score = int (input ("请输入成绩："))
if 90<=score<=100:
    print ("等级：A")
elif 80<=score<90:
    print ("等级：B")
else:
    print ("等级：C")

例子2：
代码需求：

用户输入用户名和密码
判断用户名密码是否正确（用户名admin，密码123456）
当输入用和名和密码都正确时输出 “用户admin登陆成功”
当输入其中一个错误时输出 “用户admin登陆失败”
“”"

name = input('username: ')
passwd = input('passwd: ')
if name == 'admin' and passwd == '123456' :
    print('login sucess!')
else:
    print('you cannot login in !!!')

2.2循环流程控制

在循环的时候：我们需要用到循环语句！
常用的循环语句有：
while,for语句，我们都来学习一下：

2.2.1.while循环

输出0-100之间的数！

n = 0
while n <=100:
    print(n)
    n += 1

但是while语句，存在一个问题很容易死循环：
比如：
用户尝试输入用户和密码，若是正确则登陆成功！
若是不正确则一直循环！！

try_count = 1
while True:
    name = input('username: ')
    passwd = input('passwd: ')
    if name == "admin" and passwd == "123456":
        print(f"{name} is login in when try {try_count} times!")
        exit ()
    else:
        print(f"{name}is error!")
        try_count += 1

练习
需求：输出0-100之间的偶数

count = 0
while count <=100:
    if count %2 == 0 :
        print(count)
    count += 1

若是输出1-100之间的奇数：
只需要修改一下起使直即可：n = 1

2.2.2 for循环

与传统语言中的 for 语句不同, Python 的 for语句更加简洁.
for循环原理:
可以遍历序列成员, 可以用在 列表解析 和 生成器表达式中, 它会自动地调用迭代器的 next()
方法, 捕获 StopIteration 异常并结束循环(所有这一切都是在内部发生的).

比如：输出1-100之间的偶数！
用for 不是前面的while!!

for n in range(0,101,2):
    print(n)

range语法：
range(start, end, step =1)返回一个包含所有 k 的列表, start <= k < end , k每次递增 step=1
start end step可以自己定义数字！
比如：

for语句可以循环字符串！
比如：

for item in “westos”:
print(item)

w
e
s
t
o
s

跳出循环
有时候不跳出循环，就会一直在循环语句里面循环，出不来！
这时候就需要到break和continue语句：
他们两个的区别在于：

break语句用来终止循环语句，即循环条件没False条件或者序列还没被完全递归完，也会停止执行循环语句。
continue 跳过当前循环的剩余语句，然后继续进行下一轮循环。

练习
制作一个99乘法表！
思路：
这个道题规律在于：
i j
1 1
2 1 2
3 1 2 3
…
9 1 2 3 4 5 6 7 8 9
当i取值（1-9）时候：
j取值为 (1,i + 1)
那么 操作如下：

for i in range(1,10):
    for j in range(1,i+1):
        print(f'{j}*{i}={i*j}',end=" ")
    print()

防止黑客暴力破解系统：
“”"
需求:
根据输入用户名和密码，判断用户名和密码是否正确。 为了防止暴力破解，
登陆仅有三次机会， 如果超过三次机会， 报错提示。
数据库信息:
name=‘root’ passwd=‘westos’

try_count = 1
while try_count < 4:
    print(f'user try {try_count} time!!')
    name = input('username: ')
    passwd = input('passwd: ')
    if name == "root" and passwd == "westos":
        print(f"{name} is login in when try {try_count} ci!")
        break
    else:
        try_count += 1
        print(f"{name} login is error !!")
else:
    print('user try three times! exit!!!')

3.内置数据结构字符串

首先学习：字符串的创建，赋值
字符串或串(String)是通过数字、字母、下划线组成的一串字符。Python 里面最常见的类型。 可以简单地通过在引号间(单引号,双引号和三引号)包含字符的方式创建它。

方法：
反斜杠加单一字符组成特殊字符，通常是不可打印的字符！！

转义字符 描述

(在行尾时) 续行符
\ 反斜杠符号
\’ 单引号
\” 双引号
\a 响铃
\b 退格(Backspace)
\e 转义
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数yy代表的字符，例如：\o12代表换行
\xyy 十进制数yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出

我们介绍常用的转义。

字符串的基本属性：
我们介绍一下连接操作

name = "word"
print('hello' + name)
print('*'*30 + name + "#"*30)

成员操作符：
判断是否存在：
存在输出true,不存在输出：flase

n = 'hello westos'
print('hello' in n)
print('pop' in n)

关于索引
分为正向索引和反向索引：
索引是为了获得特定偏移的元素！！
正向索引代表的位置为0，1，2，3…
反向索引代表的位置为-1,-2,-3,-4…（从右向左数）

比如：

s = 'westos'
print (s[0])
print (s[3]) #T
print (s[-3]) #T

关于切片
切片作用在于：切出一部分的内容
s[start🔚step]
s[:end]:
s[start:]:

例如：

s = 'hello world'
print(s[1:3])  # 从1开始到3-1结束
print(s[:3])  # 从0开始到3-1 结束
print(s[:5])  # 前五个字符
print(s[3:])  # 从第3个开始，到结束所有字符
print(s[::])  # 拷贝字符串  拿出所有字符串
print(s[::-1])  #倒序

可迭代对象for循环

n = 'hello'
count = 0
for item in n:
    count += 1
    print(f'di {count} ge zifu is {item}')

练习：
当用户输入一个字符串的时候，判断一下是否是回文字符串！！！

s = input('input your word: ')
if s == s[::-1]:
    print(f'{s} is huiwen!!')
else:
    print("bushi huiwen !!!!")

字符串的用法
字符串可以转换输出，判断：
下面我们先判断是否大小写，数字，字母！

字符的判断

s = 'hello westos'
print(s.isalnum())
print(s.isdigit())
print(s.isupper())

字符的转换

print('hello'.upper()) 转化为大写
print('HELLO'.lower())  小写
print('hello westos'.title())  转化为标题格式：首字母大写
print('hello westos'.capitalize()) 第一个字母大写
print('HELLO westos'.swapcase())  大小写互换

练习：
客户输入Y即可继续操作（不管大小写y|Y,或者YES|yes）

action = input("please input your action: ")
if action.lower() == "y" or action.lower() == "yes":
    print('your action is createing!!!')
else:
    print("error!!!")

字符串的开始和结尾的判断
startswith 是判断是否以指定字符串开头！
endswith 是判断是否以字符串结尾！！

例如：
判断网址的开头是否是http是的话就可以爬，不是就不可以！！

url = 'http://www.baidu.com'
if url.startswith('http'):
    print(f"{url} is a right address!!")

对于结尾的判断：
判断：文件是否以png结尾 如果是的话就是图片
结尾是mp3就是音乐，结尾是其他就是未知的文件类型！！

file = 'westos.png'
if file.endswith('png'):
    print(f'{file} is a picture!!')
elif file.endswith('mp3'):
    print(f'{file} is a mp3!!!')
else:
    print('the file is a unkown type!!')

字符串的数据清除
清除的类型分为：

lstrip: 删除字符串左边的空格(指广义的空格: \n, \t, ’ ')
rstrip: 删除字符串右边的空格(指广义的空格: \n, \t, ’ ')
strip: 删除字符串左边和右边的空格(指广义的空格: \n, \t, ’ ')
replace: 替换函数， 删除中间的空格， 将空格替换为空。replace(" ", )

s = ’ hello ’
print(s.lstrip()) 删掉左边空格
print(s.rstrip()) 删掉右边
print(s.strip()) 删掉空格
print(s.replace(" ","#")) 空格替换为#
print(s.replace(" ","*")) 空格替换为星

字符串的位置调整

center()字符串居中对齐
ljust()字符串靠左对齐
rjust()字符串靠右对齐！

比如：

print("hello westos".center(50))
print("hello westos".ljust(50))
print("hello westos".rjust(50))
print("hello westos".rjust(50,'#'))
print("hello westos".ljust(50,'#'))
print("hello westos".center(50,'#'))

结果如下：

字符串的搜索

s = "hello westos"
print(s.find('l'))
print(s.find('x'))
print(s.index("l"))
print(s.index("s"))
print(s.count('w'))
print(s.count('s'))
print(s.index("x"))

操作如下：
find如果找到子串， 则返回子串开始的索引位置。 找不到则返回-1
index如果找到子串，则返回子串开始的索引位置。否则报错(抛出异常).

字符串的分离和拼接！
例如：

ip = '172.25.254.100'
print(ip.split('.'))
items = ip.split('.')
print('-'.join(items))

先切片，然后把切片的值赋予items，再以-拼接起来！！

string模块
在使用前一定要记得调用模块
import random
import string

import random
import string
print(string.digits)
print(string.ascii_letters)
print(random.sample(string.digits,2))
print(random.sample(string.ascii_letters,2))
print("".join(random.sample(string.digits,4)))
print("".join(random.sample(string.ascii_letters,2)))

练习
生成100个验证码， 每个验证码由2个数字和2个字母组成！！

import random
import string
for i in range(100):
    print("".join(random.sample(string.digits,2)) + "".join(random.sample(string.ascii_letters,2)))

练习题

1. IP检测

编写一个函数来验证输入的字符串是否是有效的 IPv4 ?
1). IPv4 地址由十进制数和点来表示，每个地址包含4个十进制数，其范围为 0 - 255， 用(".")分割。
比如，172.25.76.1；
2). IPv4 地址内的数不会以 0 开头。比如，地址 172.25.76.01 是不合法的。

ip=str(input('please input IP: '))
ip_list=ip.split('.')
flag=True
if ip.count('.')==3 and len(ip_list)==4:
    if ip_list[0].isdigit() and int(ip_list[0]) <= 255 and int(ip_list[0]) >= 1:
        for i in range(1,4):
            if ip_list[0].isdigit() and int(ip_list[i]) <= 255 and int(ip_list[i]) >= 0:
                flag=True
            else:
                flag=Flase
                break
    else:
        flag=Flase
else:
    flag=Flase
if flag==True:
    print('IPV4!')
else:
    print('Neither!')

2.小学生计算能力测试系统

设计一个程序，用来实现帮助小学生进行算术运算练习，它具有以下功能：
提供基本算术运算(加减乘)的十个题目，每道题中的操作数是随机产生的，
练习者根据显示的题目输入自己的答案，
程序自动判断输入的答案是否正确并显示出相应的信息。最后显示正确率！！

import random

count = 10
right_count = 0
for i in range(count):
    num1 = random.randint(1,10)
    num2 = random.randint(1,10)
    symbol = random.choice(["+","-","*"])
    result = eval(f"{num1}{symbol}{num2}")
    question = f"{num1}{symbol}{num2} = ? "
    print(question)
    user_answer = int(input("answer:"))
    if user_answer == result:
        print("right")
        right_count += 1
    else:
        print:("error")
print("right percent: %.2f%%" %(right_count/count*100))

4.列表与元组

序列
成员有序排列的,且可以通过下标偏移量访问到它的一个或者几个成员,这类类型统称为序列。
序列数据类型包括:字符串,列表,和元组类型。
特点: 都支持下面的特性

索引与切片操作符
成员关系操作符(in , not in)
连接操作符(+) & 重复操作符(*)

4.1列表

先首先需要建立列表
数组: 存储同一种数据类型的集和。scores=[12,95.5]

列表(打了激素的数组): 可以存储任意数据类型的集和。

创建空列表：

li = []
print(type(li))

创建一个包含元素的列表，元素可以是任意类型，
包括数值类型，列表，字符串等均可, 也可以嵌套列表。

list = [1,2,3]
print(type(list))
list1 = [1,2,['hello','westos']]
print(type(list1))

列表的基本性质

连接操作符，重复操作符
比如：

print([1,2] + [2,3])
print([1,2] * 2)

列表之间可以直接相加输出，或者乘以数字，重复输出！

成员操作符
包括in,not in
来判断真假（true/flase）
比如：

print(1 in [1,2,3])
print(4 in [1,2,3])

索引
输出某个位置的数字
后面的列表嵌套列表形式，嵌套内的列表整体表示一个索引

list = [1,2,3,[4,5,6]]
print(list[0])
print(list[-1])
print(list[-1][1])
print(list[-1][-1])

切片
比如：

list = ['172','25','254','100']
print(list[:2])#'172','25'
print(list[2:])
print(list[::-1])
print('-'.join(list[::-1]))

例：

#需求 已知li 输出 1-76-25
print('-'.join(li[1:][::-1]))

**for 循环**
n = ['westos','linux','python']
for items in n:
    print(f'obj is {items}')

处理列表的方法有：
1.增加
增加分为好几种类别：追加，开头加，索引添加

#(1)追加4
list = [1,2,3]
list.append(4)
print(list)
#(2)在列表开头添加4
list = [1,2,3]
list.insert(0,4)
print(list)
#(3)在索引2前面添加4
list = [1,2,3]
list.insert(2,4)
print(list)
#(4)扩展多个元素
list = [1,2,3]
list.extend([4,5,6])
print(list)

2.修改
直接在列表里用索引替换！

list = [1,2,3]
list[0] = 'westos'
list[2] = 'hello'
print(list)

查看
方式：
(1)通过索引和切片查看元素
(2)通过索引值和出现次数

count()统计某数字出现的次数
index()统计某数字的索引是多少

list = [1,2,3,4,2,3,3,2,1,1,4,6]
print(list.count(3))
print(list.index(3))

删除
删除也有多种删除方式：
索引删除，value删除，全部清除
例如：

list = [1,2,3,4]
del_list = list.pop(0)
print(list)
list = [1,2,3]
list.remove(2)
print(list)
list = [1,2,3]
list.clear()
print(list)

拷贝，反转，排序

list = [4,2,5,1,3]
list.sort() ##排序
print(list)
list.reverse() ##反转
print(list)

list1 = list.copy() ##复制
print(id(list),id(list1))

排序sort本来是从小到大的排列，如果加上reverse=True就可以实现从大到小的排列

5.元组

元组tuple（俗称：戴了紧箍咒的列表）
当元组中只有一个元素的时候，要加逗号，如：（1，），不然输出类型就为整型（int）

t1 = ()
print(t1,type(t1))
t2 = (1,)
print(t2,type(t2))

元组的特点
元组是不可变数据类型（不能增删改）

查看：通过索引和切片查看元素，查看索引值和出现次数

t = (1,3,2,2,3,5,4,1,1)
print(t.count(1))
print(t.index(2))

命名元组

#从collections模块中导入namedtuple工具
from collections import namedtuple
#1.创建命名元组对象User
User = namedtuple(‘User’,(‘name’,‘age’,‘city’))
#2.给命名元组传值
user1 = User(“hello”,18,“西安”)
#3.打印命名元组
print(user1)
#4.获取命名元组指定的信息
print(user1.name)
print(user1.age)
print(user1.city)


from collections import namedtuple
user = namedtuple('user',('name','age','city'))
user1 = user('westos',18,'xian')
print(user1)
print(user1.name)
print(user1.age)
print(user1.city)

is和==的不同

Python中对象的三个基本要素，分别是：id(身份标识)、type(数据类型)和value(值)。

is和==都是对对象进行比较判断作用的，但对对象比较判断的内容并不相同。

==用来比较判断两个对象的value(值)是否相等；(type和value)
is也被叫做同一性运算符， 会判断id是否相同;(id, type 和value)
所以is判断的比较全面，比 双等 要条件多！！

【或者说：== 是判断类型和值是否相同！ is :是判断类型和值，以及内存地址是否相等！】

练习
编写一个云主机的管理系统！！
要求如下：

• 添加云主机(IP, hostname,IDC)
• 搜索云主机(顺序查找)
• 删除云主机
• 查看所有的云主机信息

from collections import namedtuple
menu = """
1).add host
2).search host
3).deleted host
4).list all host
5).exit
input your choice: """
hosts = []
host = namedtuple('host',('ip','hostname','id'))
while True:
    choice = input(menu)
    if choice == '1':
        print('add host: '.center(50,'*'))
        ip = input('ip: ')
        hostname = input("hostname: ")
        id = input('id(eg:alibaba,huawei,xiaomi..):')
        host1 = host(ip,hostname,id)
        hosts.append(host1)
        print(f"add{id}is ok!.IP is {ip} and id is {id}")
    elif choice == '2':
        print('search host: '.center(50,'*'))
        search_hostname = input('hostname: ')
        for host in hosts:
            if search_hostname in host.hostname:
                print(f"{host.id}\t{host.ip}\t\t{host.hostname}")
                break
        else:
            print(f"not found hostname: {search_hostname}")
            print(f"{hostname.ip}\t{hostname.hostname}\t{hostname.id}")
    elif choice == '3':
        print('deleted host: '.center(50,'*'))
        delete_id = input('input id: ')
        for host in hosts:
            if host.id == delete_id:
                hosts.remove(host)
                print(f"delete  host {host.hostname} sucess!!")
                break
        else:
           print(f"not found : {delete_hostname}")
    elif choice == '4':
        print('list all: '.center(50,'*'))
        print("IP\t\t\thostname\tid")
        count = 0
        for host in hosts:
            count += 1
            print(f"{host.ip}\t{host.hostname}\t{host.id}")
        print('sum is: ', count)
    elif choice == '5':
       print("系统正在退出，欢迎下次使用......")
        exit()
    else:
        print("请输入正确的选项")

重点：深拷贝，浅拷贝

对于深拷贝和浅拷贝的区别：
浅拷贝： 对另外一个变量的内存地址的拷贝，这两个变量指向同一个内存地址的变量值。(li.copy(), copy.copy())如上图！
同时公用一个值；这两个变量的内存地址一样；对其中一个变量的值改变，另外一个变量的值也会改变；

深拷贝： 一个变量对另外一个变量的值拷贝。(copy.deepcopy())
两个变量的内存地址不同；两个变量各有自己的值，且互不影响；对其任意一个变量的值的改变不会影响另外一个；

对于深浅拷贝：
浅拷贝：

n1 = [1,2,3]
n2 = n1.copy()
print(id(n1),id(n2))
n1.append(4)
print(n2)

1.和前面值的引用不同：n2 = n1后，n1的改变，也会让n2改变
2.但是n2 =n1.copy()拷贝后，n1的改变不会使得n2改变

深拷贝：

如果列表的元素包含可变数据类型, 一定要使用深拷贝

可变类型：
可变数据类型(可增删改的): list
不可变数据类型:数值，str， tuple， namedtuple

例如：

n1 = [1,2,3,[1,2]]
n2 =n1.copy()
print(id(n1),id(n2))
print(id(n1[-1]),id(n2[-1]))
n1[-1].append(4)
print(n2)

浅拷贝：

判断的最佳方式：

深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。
假设B复制了A，修改A的时候，看B是否发生变化

那么如何实现深拷贝呢

import copy
n1 = [1, 2,3， [1, 2]]
n2 = copy.deepcopy(n1)
#n1和n2的内存地址:拷贝！
print(id(n1), id(n2))
#n1[-1]和n2[-1]的内存地址:
print(id(n1[-1]), id(n2[-1]))
n1[-1].append(4) # n1 = [1, 2, [1, 2, 4]]
print(n2)

结果如下：
说明深拷贝也将列表里面的列表拷贝了
所以再查看id的最后一位时，id不同

6.集合

集合是一个无序的不重复元素序列。
集合的元素必须时不可变数据类型！
空集合不能使用{}, 而要使用set()
只显示一次出现过的数字！
1,2,3,4,1,2,3，4，3，2 = 1,2,3,4

创建一个集合

s = {1, 2, 3, 1, 2, 3}
print(s, type(s))

若在集合里面加入可变元素就会报错
空集合不能使用{}，它会显示是个字典！ 而要使用set()

集合的特点
集合不支持 加 ，index, slice
支持in和not in

集合中常用的操作
1.增加
往集合中添加元素：有add,update两种方式！！

i = {1,2,3}
i.add(5)
print(i)

i.update({3,5,7})
print(i)

2.删除

三种方式：
remove,pop,discard

remove: 如果元素存在，删除，否则报错
discard: 如果元素存在，删除，否则不做任何操作
pop: 随机删除元素，集合为空则报错

s = {1,2,3,4}
s.discard(5)
print(s)
s = {1,2,3,4}
s.remove(5)
print(s)

集合间的关系：
差集: s1 - s2
交集: s1 & s2
对称差分: s1 ^ s2
并集: s1 | s2
s1.issubset(s2):判断s1是否是s2的子集！！
isdisjoint的功能：
判断两个集合是否包含相同的元素，如果没有返回True，否则返回False

s1 = {1, 2, 3}
s2 = {1, 2}
print(s1 - s2)
print(s1 & s2) #交集
s1 = {6, 5, 3}
s2 = {1, 2, 4}
print(s1 ^ s2) #对称差分 即刨开都有的
print(s1 | s2) #并集
print(s1.issubset(s2)) #是不是子集
print(s1.isdisjoint(s2)) #没有交集吗？

练习
题目：
小明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从大到小排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据，希望大家能正确处理)。

import random
N = int(input("input your num ! "))
s = set()
for item in range(N):
    s.add(random.randint(1,1000))
s = sorted(s)
print(s)

因为输入1-1000的数字！
所以需要输入N转化为int

frozenset：不可变的集合
frozenset 是 set 的不可变版本，因此 set 集合中所有能改变集合本身的方法（如 add、remove、discard、xxx_update 等），frozenset 都不支持；
set 集合中不改变集合本身的方法，fronzenset 都支持。
frozenset 的这些方法和 set 集合同名方法的功能完全相同。

frozenset 的作用主要有两点：

1，当集合元素不需要改变时，使用 frozenset 代替 set 更安全。

2，当某些 API 需要不可变对象时，必须用 frozenset代替set。比如 dict 的 key 必须是不可变对象，因此只能用 frozenset

3,再比如 set 本身的集合元素必须是不可变的，因此 set 不能包含 set，set 只能包含 frozenset。

例如：

s = frozenset({1,2,3,4})
print(s,type(s))

7.字典

字典是另一种可变容器模型，且可存储任意类型对象。
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

先创建字典

d = {'name':'westos','age':18,'obj':'linux'}
print(d,type(d))
d = {}
print(d,type(d))

字典和集合的区别在于：字典里的元素中间用：来解释！
集合之间只有逗号隔开！

字典的特点
不支持+,*, index, slice(因为集合无序不重复的)
支持in和not in

如：

d = {'name':'linux','age':20,'obj':'python'}
print('name' in d)
print('city' in d)

字典的用法
首先：字典的查看
查看所有：keys,values,items
看局部：d[key],d.get(key),d.get(key,default-value)

因为字典是由key-values组成的！！

d = {'name':'linux','age':20,'obj':'python'}
print(d.keys()) # 查看字典所有的key值
print(d.values()) #查看字典所有地value值
print(d.items())#查看字典所有地key-value值（items 元素）

print(d['name']) #查看key-name对应地value值
print(d.get('name')) #查看key-name对应地value值
print(d.get('city','xian')) ##查看key对应地value值，如果存在返回，如果不存在返回默认值

print(d.get('province')) #查看key对应地value值，如果存在返回，如果不存在返回None

增加，修改
增加的方式比较简单！

d = {"name":"linux","age":18}
d['city'] = "xian" # key不存在就添加
print(d)

修改：

d = {"name":"lcf","age":18}
d['city']= "xian" # key不存在就添加
print(d)
d['city'] = "shenyang"  # key存在就修改
print(d)

还有一种添加的方式
若是不存在就添加，存在的话就什么都不做（就是不改变！）

d = {"name":"linux","age":18}
d.setdefault('city',"xian") # key不存在就添加
print(d)
d.setdefault('city','chengdu') #key存在do nothing
print(d)

删除
删除的两种方式：
先定义字典 d

1.一种和集合一样d.pop( )
2.另一种del d[ ]

d = {"name":"linux","age":18}
d.pop('name')
print(d)
d = {"name":"linux","age":18}
del d['age']
print(d)

遍历字典
就是for循环
例如：

d = {"name":"linux","age":18,'city':'xian'}
for item in d: # 默认情况下，字典只会遍历key值
    print(item)
for item in d.items(): #如果遍历字典地key和value值
    print(item)
for key,value in d.items():
    print(f"key={key},value={value}")

练习题
两数之和：

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

思路如下：

从给定列表中依次不放回的取出一个数字,取一个新列表（mirror）存放这个数字，用target减去该数字，看差值是否在所给列表中。若在，将差值也存放在mirror中，然后找出这两个值在给定列表中的位置并输出；若不在，将mirror中的数字弹出(我用的remove)，继续下一个数字。相当于遍历的方法。

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in range(len(nums)):
            dif = target - i
            if dif in nums:
            return[nums.index(dif),nums.index(i)]

拓展：defaultdict
collections.defaultdict类，本身提供了默认值的功能， 默认值可以是整形，列表，集合等.

defaultdict 是 dict 的子类。但它与 dict 最大的区别在于，如果程序试图根据不存在的 key 访问 value，会引发 KeyError 异常；
而 defaultdict 提供default_factory 属性，该为不存在的 key 来自动生成生成默认的 value。

问题
需要将一个key映射到多个值的字！！

方式：
可以用到刚才所说的：
collections.defaultdic

操作如下：

from collections import defaultdict
d = defaultdict(list)
d['allow_users'].append("user1")
print(d)

d = defaultdict(set)
d['love_movies'].add("你好 李焕英")
print(d)

能够映射两种类型

练习
请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

str0 = input("请输入一组字符串：")
def flongest(str):
    list0=[]
    length=len(str) 
    for i in range(length):
        sum = str[i]
        for j in range(i+1, length):
            if str[j] not in sum:
                sum += str[j]
            else:
                break
        list0.append(sum)
    N=len(list0)
    for n in range (N):
        for m in range(n+1,N):
            if len(list0[n])<len(list0[m]):
                list0[n],list0[m]=list0[m],list0[n]
    return list0[0]
longest_str=flongest(str0)
longest_str_length=len(flongest(str0))