python进阶

1 集合

1.1 List列表

• 列表（List）是一种有序和可更改的集合。允许重复的成员。

• 列表是一个有序且可更改的集合。在 Python 中，列表用方括号编写。

• 通过引用索引号来访问列表项

• 更改特定项的值

• 遍历列表

• in

• 列表长度

• 添加项

  • append
  • insert

• 删除项

  • remove
  • pop

• 复制

  • copy

• 合并

  • extend

• 列表方法

  • sort
  • reverse

代码例子

List列表 - 是一种有序的可以更改的集合，列表中的元素可以重复

• 创建列表可以使用[] 或者 list()

• 创建空的列表

nums = [] 
nums = list() 
# print(nums) 

• 非空的列表

nums = [2,4,6,8,8]
print(nums)    #[2, 4, 6, 8, 8]   存放有序，允许有重复的元素

ss = ['hello','python','web','web',20]    
print(ss)   #['hello', 'python', 'web', 'web', 20]

'''
> 列表每一个元素都分配一个整数，称为索引，左边从0开始（正索引），右边从-1开始（负索引） 
['hello','python','web','web',20] 
    0        1      2     3    4
    -5      -4     -3    -2   -1

• 使用[索引]访问列表中的元素

print(ss[0]) 
print(ss[-5]) 
print(ss[-1]) 

• for in - 遍历列表

for s in ss:
    print(s)

• len() - 获取列表长度

print(len(ss)) 
print(len([]))  

• 修改列表中的元素

ss[2]='java' 
print(ss) 

• in - 检查列表中是否包含给定的元素

print('java' in ss)   #True
print('js' in ss)   #False

print(type(ss))   #返回变量的类型  list

• • 列表拼接，生成新的列表

print(id(ss))  # id() - 返回变量的内存地址
ss2=ss+[40,69]
print(ss) 
print(ss2) 
print(len(ss2))
print(id(ss))  

• append() 列表的末尾添加一个元素 - 追加

# print(id(ss))  # id() - 返回变量的内存地址
# ss.append([33,51])
# print(id(ss))  
# print(ss)
# print(len(ss))

• extend() 列表末尾逐个添加给定集合中的元素 - 合并

# ss.extend([33,51])
# print(ss)
# print(len(ss)) 

• insert() 指定索引位置上插入一项

# ss.insert(1,[33,51])
# print(ss) 
#print(ss[10])   #IndexError: list index out of range

• remove() 删除给定的一个元素，（如果有多个，只删除左边开始第一个）

# ss.append('web')
# print(ss) 
# ss.remove('web')
# print(ss) 
# ss.remove("js")   #ValueError: list.remove(x): x not in list

• pop() 弹出指定位置的一个元素，并且返回弹出的元素 默认是最右边的元素

# print(ss) 
# s = ss.pop(1) #参数指定位置（索引）
# print(s)
# print(ss) 

• 新建变量指向的是同一个列表

# ss2 = ss 
# print(id(ss))
# print(id(ss2)) 

• copy() - 复制，新建了一个列表，并且把原列表的元素复制进新的列表

# ss2 = ss.copy()
# print(id(ss))
# print(id(ss2)) 
# print(ss)
# print(ss2)  
nums=[20,21,6,18]

• reverse - 列表元素反转

nums.reverse()
print(nums)   #[18, 6, 21, 20]

-sort() - 列表中元素排序，升序排序

nums.sort()
print(nums)  

• list*n - 列表元素复制n次 , 原来列表不变

print(nums*4)

• min() - 返回列表中最小的元素
• sum() - 返回列表中所有元素的和
  • print(max(nums),min(nums),sum(nums))

1.2 Tuple元组

• 元组是有序且不可更改的集合。在 Python 中，元组是用圆括号编写的。
• 通过引用方括号内的索引号来访问元组项
• 创建元组后，您将无法更改其值。
• 使用 for 循环遍历元组项
• in
• 元组长度
• 创建仅有一个元素的元组
• 合并两个元组

代码例子

• Tuple - 元组，是一种有序且不可更改的集合

• 创建一个元组可以使用() 或者 tuple()

  • 空的元组

nums=()
nums = tuple()  
print(nums) 

• 非空的元组

nums=(2,4,6,8,8)  
nums=tuple([2,4,6,8,8])   #新建一个元组，将列表中的元素依次存放进来
print(nums)     #(2, 4, 6, 8, 8)   存放有序 ，元素可以重复  

ss=('python','java','web',20) 
print(ss)  

• in 检查元组是否包含给定的元素

print('js' in ss)  #False

• len() 元组长度

print(len(ss)) 

• for in 遍历

for x in ss:
    print(x) 

• [索引]获取元组中的元素

print(ss[0]) 
print(ss[-1]) 

• 元组中的元素不能重新赋值

#ss[0] = 'js'   #TypeError: 'tuple' object does not support item assignment

• • 合并，生成新的元组，原来的元组是不变的

ss2=ss+(3,5)
print(ss)  
print(ss2) 

• *n 元素复制 原来的元组不变

print(ss*2)

下面创建的是一个int

• ts=(1)

  • 创建仅有一个元素的元组
  • ts=(1,)
  • print(ts,type(ts))

• tuple->list

# ls = list((20,21,6,18))    #创建一个列表，将元组中的元素依次添加到列表中
# ls.sort()
# print(ls) 


ts=('hello','python','java','web','js')
print(max(ts),min(ts))     

• tuple用处
• 函数返回值用tuple存放
• 可变参数

def test(*args):
    print(args)
    
test(2,5,3,4) 


dd = ('python',[2,4],20)
print(dd[1][1])
dd[1][1]=33
print(dd) 
# dd[1]=[2,33]  #TypeError: 'tuple' object does not support item assignment

1.3 Set集合

• 集合是无序和无索引的集合。在 Python 中，集合用花括号编写。

• 使用 for 循环遍历

• in

• 添加项

  • add
  • update

• 集合长度

• 删除

  • remove

• 合并两个集合

  • union

• 集合方法

  • defference
  • intersection

代码例子

• set - 集合是一组不能重复的元素的集合。集合是无序的，使用{}定义集合。

• set() - 创建一个空的set,不使用{}

# s = set()
# print(s,type(s)) 

• 包含元素的set 重复的元素保留一个，存放无序

# s = {'python','java','web','web'} 
# print(s,type(s))

• 把一个列表元素存成一个set

s = set(['python','java','web','web'])  #{'web', 'python', 'java'}
print(s) 

• set 无法用[]获取元素

#print(s[0]) 
```'

# for in 语句遍历
for c in s:
    print(c)  

# add() 增加元素
# s.add('php') 
# s.add('java') 
# print(s) 

# remove() 删除给定的元素
# s.remove('java') 
# print(s) 

# pop()  - 随机从set中删除一个元素   
s.pop()  
print(s) 

set操作

创建空的set

s = set()
- update() - 添加多个元素 
s.update({100,99,95,94}) 
print(s)  
s.update(['python','java'])  
print(s) 

• len() - 返回set中元素的个数

print(len(s)) 

s1 = set('apple')
print(s1) 
s2 = set('banana')
print(s2) 

• difference 差集

print(s1-s2)  #把s2中包含的元素从s1中删除
print(s1.difference(s2))  #把s2中包含的元素从s1中删除
print(s2.difference(s1))  #把s1中包含的元素从s2中删除

• symmetric_difference 对称求差别

print(s1.symmetric_difference(s2))  
print(s2.symmetric_difference(s1))  

• intersection() - 交集

  • print(s1.intersection(s2))

• union() - 并集

  • print(s1.union(s2))

1.4 Dictionary字典

• 字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。

• 通过在方括号内引用其键名来访问字典的项

• 通过引用其键名来更改特定项的值

• 使用 for 循环遍历字典

• values()-返回字典的值

• items()-返回键和值

• in

• 字典长度

• 添加项

• 删除项

  • pop

• 字典方法

  • get
  • keys

代码例子

Dictionary - 字典

• 用{}创建字典,键（key）和值(value)之间用冒号(:)分割，键值对之间用逗号(,)分割

  • d1 = {100:"hello","python":[2,4,6]}
  • print(d1,type(d1)) # dict-字典

• 创建一个空的字典用dict()函数

  • d2 = dict()
  • print(d2,type(d2))

• {}创建空的字典

  • d3 = {}
  • print(d3,type(d3))

• 创建字典

  • user={'username':'zhang','age':20}
  • print(user)

• [key]获取key对应的value

  • print(user['username'],user['age'])

  • print(user['sex']) #KeyError: 'sex'

• 新建一个键值对

  • user['sex']='男' #'sex'在字典中不存在
  • print(user)

• 根据键修改值

  • user['age']=22 #'age'在字典中已存在
  • print(user)

# user['username']='xiaoming'
# user['age']=18
# user['sex']='女'
# print(user)

#update(dict)    - 用给定的字典同时增加或修改原字典）
xm = {'username':'xiaoming','age':18,'no':1001} 
user.update(xm)
print(user)       

• 同一个字典中键不能重复，不可变的类型（如：数字、字符串、元组）可以作为键
  • d3 = {'hello':100,'python':100,('java',):100} #列表是可变的，不能作为键
  • print(d3)

print(d3.get('age',20) ) #get() - 根据关键字获取值，但是关键字不存在，不报错，返回指定的值，默认返回None

• pop(key) - 根据键删除键值对

  • value = d3.pop('hello') #返回键对应的值，如果键不存在，抛出错误KeyError
  • print(value)
  • print(d3)

• clear() - 清空

  • 3.clear()
  • print(d3)

字典遍历

scores={'python':100,'java':100,'web':99}
scores['js']=98 
print(scores) 

• keys() - 获取键 ,返回的类型是dict_keys

print(scores.keys(),type(scores.keys()))   
#list() -  dict-keys -->list
ks = list(scores.keys() )
print(ks[0])  

• values() - 获取值 ,返回dict_values

vs = scores.values()
print(vs,type(vs))  
vs = list(vs)
print(vs) 

• for in 语句遍历
  • for k in scores:
  • print(k,scores[k]) #字典中的键

# scores['php']=97
# scores['php']=0  
# print(scores) 
sc = scores.setdefault('php',0)
print(scores) 
print(sc) 

字典存放列表数据

names = ['zhang','lisi','xiaoming','zhao','liu'] 
scores = [95,88,99,90,95,10]  

students={}
for i in range(0,len(names)):
    students[names[i]]=scores[i]

print(students) 
print(students['liu']) 

• zip() - 拉链

z = zip(names,scores)
stu = dict(z)  
print(stu) 

• copy() - 拷贝
  • stu2 = stu.copy() #创建新的字典
• stu2 = stu # 不创建新的字典

print(stu,id(stu)) 
print(stu2,id(stu2)) 

• hash() - 哈希函数

# print(hash('zhang'))  
# print(hash('zhang'))  
# print(hash('lisi'))  

# stu3={}
# stu4 = stu3.fromkeys(names)   #创建一个新的字典并返回  把names中的元素作为键
# print(stu4)
# print(stu3.fromkeys(names,0))  #指定键对应的值，如果不指定，默认值是None

• items() - 返回dict_items

its = stu2.items()
print(its,type(its))  
its = list(its)   #[('zhang', 95), ('lisi', 88), ('xiaoming', 99), ('zhao', 90), ('liu', 95)]
it =its[0]     #('zhang', 95)
print(it[0],it[1])   

• in - 检查字典中是否有给定的键

  • print('zhou' in stu2) #False
  • print('lisi' in stu2) #True

• len(dict) - 返回字典中键的数量

  • print(len(stu2)) # 一个键值对算一个

2 模块

• 模块
• 包
• 内置模块

2.1 什么是模块

• 模块是包含一组函数的文件，希望在应用程序中引用。

• 创建模块

• 使用模块

• 模块中的变量

• 命名

• 内建模块

  • platform

• 从模块导入

2.2 包

• 包是一个分层次的文件目录结构。
• 简单来说，包就是文件夹，但该文件夹下必须存在 init.py 文件, 该文件的内容可以为空。

代码例子

创建模块

# mymath.py
def say():
    print("hello")
​
def is_leapyear(year):
    return year%4==0 and year%100!=0 or year%400==0
​
​
pi=3.1415926
​
def circle_area(r):
    return pi*r**2 

创建包

# aowin/hellomodule.py
def rate(x,y):
    return (y-x)/x 

使用模块

import mymath
import aowin.hellomodule as hm
​
mymath.say()
​
print(mymath.is_leapyear(2020))
print(mymath.is_leapyear(2021))
​
print(mymath.pi)
​
print(mymath.circle_area(10.0)) 
​
print(hm.rate(4,8))  
​

数学模块

• python内置模块的导入使用import
  • import 模块名字

import math,random
# import random 

• 访问模块中的变量

# print(math.pi,type(math.pi)) 
# print("%.100f" % math.pi) 
# print(math.nan)

• 内置函数 直接使用
  • print(pow(2,10)) ​
• 访问模块中的函数 通过模块名调用

# print(math.sqrt(100))
# print(math.pow(2,10))
# print(math.cos(0),math.cos(math.pi/2))  
# print(math.isnan(float('nan')))    # isnan - is not a number

# random.random() - 产生[0,1)之间的随机数
for i in range(10):
    print(random.random())    

随机数模块

• 给模块起别名，方便使用

  • import 模块名 as 别名
  • import random as rd

• 导入模块中的函数名或者变量名

  • from 模块名 import 函数名或者变量名
  • from random import choice
  • from random import choice as cho -一次导入多个函数，函数名中间用逗号(,)分割
  • from random import choice,random
  • from random import *

• random() - 随机小数

# print(rd.random()) 
# randint()
# randint(a,b) - 在[a,b]范围的随机整数
# print(rd.randint(1,6))  
# randrange(a,b) - 在[a,b)范围的随机整数  # for i in range(20):#     print(rd.randrange(1,6)) # print(rd.choice([2,4,6,8,'apple'])) 

print(choice([1,3,5,7,9]),random(),randint(1,6))  

• 直接导入模块小所有函数，使用时可能会产生歧义

  • def random():
  • return 10

• print(random())