机器学习语言必备-Python语言入门(一）
Python基础+数据科学基础[Numpy/Pandas/Matplotlib/Scipy]
1.Python语言介绍& 为什么Python如此受欢迎？
- Python语言特点
- Python：面向对象+解释型
- Python解析器：4种
- Cpython
- Jpython
- IronPython
- PyPy
- Python版本
- Python2.x版本
- Python3.x版本
- 最大的区别就是print(输出语句)
- Python的应用广、优点多 ; 缺点：Python执行速度较慢----Julia语言执行速度比python快
- Python设计哲学—接近人类自然语言------Python胶水语言-------Python不要重复造轮子
2.Python基础环境及PyPi介绍
- Python基础环境安装—参考python官网：www.python.org
- python2和python3-直接下载exe(更好)或msi文件进行安装即可
- 安装完按成后使用python2和python3进行简单的代码编写-----python module/comand line
- Java—组织java代码的方式.java文件-----jar包-------maven仓库-----在线(maven install)和离线下载
- Python—组织python语言的方式.py文件----whl包----pypi(python package index)—在线和离线下载
- 在线安装pip install numpy
- numpy-1.15.4-cp27-cp27m-manylinux1_i686.whl (10.2 MB)
- numpy-1.15.4-----------cp27(python27)-------------manylinux(linux版本)----i686平台
- 文件后缀whl轮子文件
- whl轮子文件
- 安装 : pip install xxx
- 卸载 : pip uninstall xxx
- 更新 : pip install -U xxx
- 展示 : pip list
3. Anaconda数据科学环境安装
- Anaconda分为Python2和Python3版本----平台版本
- 安装的时候直接下一步安装，需要注意的是将Anaconda环境变量配置到PATH中，并且注意位置
- Anaconda中很多的组件—注意：Anaconda是数据科学开发环境(集成了python环境+多个数据科学包)
- Anaconda Navigater–导航—打开jupyter、Spyder
- Anaconda Prompt----在不同的环境下安装卸载或展示package
- Anaconda Ipython----增强式的python ,
- Anaconda jupyter notebook-----提供web服务访问网站交互式的书写代码
- 学会使用jupyter书写代码----------公司工业场景+pycharm
- 修改jupyter的notebook_dir的存储路径 , 修改jupyter_notebook_config.py的第202行修改那处即可
- 打开jupyter命令 :
jupyter notebook
- Spyder—IDE(集成开发环境)----仿照Matlab
常用命令 :
安装包：pip install xxx,conda install xxx
卸载包：pip uninstall xxx,conda uninstall xxx
升级包：pip install upgrade xxx,conda update xxx
环境变量 :
C:\software\anaconda3;
C:\software\anaconda3\Scripts;
C:\software\anaconda3\Library\bin
顺序要按照上面的
4.Conda的主要操作
- conda命令—pip命令----均可完成python包的安装、卸载、更新等操作
- pip list conda list
- pip install xxx conda install xxx
- pip install -U xxxx conda install -U xxx
- pip uninstall xxx conda uninstall xxx
- Conda究竟和pip差别在哪里?
- 在conda安装时候显示是使用pip显式安装
- conda命令可以创建单独的python环境(可以创建不同版本的python环境)
- conda create tensorflow python==2.7.0
- 创建了一个名字叫做tensorflow的环境并且python版本是2.7.0
- 该命令创建好之后是独立的沙箱环境
5.Pycharm+Anaconda环境整合
- 安装pycharm
- 通过pycharm整合Anaconda
- 通过setting的python-interpreter功能设置python解析器(全局设置)
- 通过python文件的右上角设置环境，进行局部设置
- 将python script进行设置—加入编码方式、名字、作者、时间、文件名
Pycharm新建模板默认添加作者时间等信息
1.打开pycharm，选择File-Settings
2.选择Editor--Color&Style--File and Templates--Python-Script
3.填加
#-*- coding: utf-8 -*-
# @Time : ${DATE} ${TIME}
# @Author : Z
# @Email : S
# @File : ${NAME}.py
6.Python版本差异
- Python的print差别
- python2中-print是一个语句
- python3中print是一个函数-()
- Python编码方式差别
- python2中是ascii码
- python3中是unicode码
7.python编码解码
- Python编码方式差别
- python2中是Ascii码
- python3中是unicode码
- encode : 注意编码格式
- decode
8.python语言的数据类型
-
Python的package
-
自带package
- os : os.getcwd() ---->获取当前的路径
- os.chdir(path) —>修改当前路径 , path为要修改的路径 , 常用于将数据与程序放在同一路径
-
外部package
- easy-install
- pip()
import requests as rq r = rq.get("https://www.baidu.com") print(r.text) #获取网站的text print(r.url) #获取网站的url print(r.encoding) #获取编码方式 print(r.headers) #获取网站的header print(r.content) #获取网站的content
-
- Python的导入
- import 模块名
- 使用方式 :
模块名.函数名(参数)or模块名.变量名
- 使用方式 :
- from 模块名 import 函数名或变量名(多个函数名用逗号分隔)
- import 和 from … import区别 : import只能导入整体包, 而from…import可以导入模型中的具体对象
- 如
import math|||||from math import sin
- import 模块名
- 数值类型
- 总体 : numerics, sequences, mappings, classes, instances, and
exceptions - Numeric Types : int(包含boolean) , float , complex(复数)
- 实部(real)
- 虚部(imge)
- 直接赋值使用而不需要进行显示类型的定义 , 使用type查看类型
- 同时id查看内存中的值，hash查看hash值
- +、-、、/、*、//整除
- 单目运算符 + , - , * , / …
- 双目运算符 += , -= ,*=
- 其他操作
- 总体 : numerics, sequences, mappings, classes, instances, and
a = 199
print(type(a)) # <class 'int'>
b = 1.0
print(type(b)) # <class 'float'>
c = complex(1, 3) # 1+3j
print(c) # (1+3j)
print(c.real) # 实部1.0
print(c.imag) # 虚部3.0
print((c ** 2)) # (-8+6j)
x = 2
y = 3
# 单目运算符----- + ,- ,* ,/ , % ,** , //
print(x + y)
print(x - y)
print(x * y)
print(x / y)
print(x ** y)
print(x // y)
print(x % y)
# 双目运算符---- += , -= , *= , /= , **= , //= , %=
x += y
print(x)
x -= y
print(x)
# & 按位与(同1则1 , 其他为0) , | 按位或(有1则1 ,其他为0) , ^按位异或(相同为1 , 不同为0) , <<左移(乘2) , >>右移(除2)
a = 3
b = 5
print(a & b) # 1
print(a | b) # 7
print(a ^ b) # 6
print(a << 2) # 12
print(a >> 1) # 1
- 字符串、常量
- 科学计数法 ----- e的用法
- 引号–三引号进行
原样输出，如何去掉换行，加\ - 三引号是字符的原样输出
# 科学计数法
print(3.14e2)
print(3.14e-2)
# " "" '''
str1 = "传智播客"
str2 = '传智播客'
str3 = '''\
传智播客1
传智播客2
传智播客3\
'''
# \是用来取消换行的
print(str1)
print(str2)
print(str3)
9.python的输入
- python2和python3区别
- python2中
- raw_input–无论输入的是什么，输出一定是string类型
- input—原样输入，如果是string类型务必加引号
- python3中
- 只有input，input和python2中的raw_input是相似的 ,如果输入的是整形的数据，请务必进行强制类型转换
- python2中
#python2中input是原样输入
#如果输入的是字符串类型，请务必加上括号，明确表示
# input1 = input("please input your age:") #NameError: name 'zhangsan' is not defined
# print(input1)
# print(type(input1))
# # please input your age:"zhangsan"
# # zhangsan
# # <type 'str'>
#raw——input--无论输入的是什么输出的都是string类型
# input2=raw_input("please input your age:")
# print(input2)
# print(type(input2)) #<type 'str'>
#python3中的input和python2中raw_input一致
#python3将raw_input和input进行了整合，只有input
age=int(input("please input your age:"))
print(age)
print(type(age))
10.python输出语句
- print
- 格式输出
- 1.直接用逗号进行拼接
- 2.直接用+进行拼接，需要注意的是
非字符类型的(数值类型)需要转换为str类型 - 3.用{}形式，
.format结构 , 但是必须从0开始 - 4.用{0}-{1}…format()结构
- 5.用%形式给定类型进一步输出 —%d , %f
age=12
name="zhangsan"
print("name is:",name,"age is:",age,"Over")
print("name is:"+name+"age is:"+str(age)+" Over") #TypeError: must be str, not int
# 一下两种常用!!!!
print("name is {},age is {},Over".format(name,age))
print("name is {0},age is {1},Over".format(name,age))
# 上面的索引必须从0开始 , 否则出错
print("name is:%s,age is %d,Over"%(name,age))
11.python随机数生成程序
- python自带的random
- python的numpy中的random模块产生的是矩阵的随机数
import random
print("[0,1):",random.random())
print("[a,b]:",random.randint(1,10)) # range [a, b]
print("start stop:",random.randrange(1,10,2))#Choose a random item from range(start, stop[, step]). 获取到的是左闭右开区间中的奇数
str=[1,2,3,4]#有序
# shuffle打乱顺序
random.shuffle(str)
print(str) #[2, 1, 3, 4]
import numpy as np
print("normal data:\n",np.random.randn(5,5))
print("normal data:\n",np.random.chisquare(10,size=(5,5)))
12.python的四种数据结构详解
- list列表：有序、异质、根据下标进行查询、更新、删除等操作
- 【】定义 , list函数 , 可变的根据下标查询 , 修改 , 删除等数据结构
- tuple元祖:有序，异质，根据下标进行查询，但是更新和删除操作的话无法实现
- () 定义 , tuple()函数 , 不可变的根据下标查询 , 不支持修改 , 删除
- dict字典：无序、异质、根据key查询value，根据key更改value，根据key删除value
- {key : value} , 根据key创建 , 查询 , 删除value的结构 , 有序字典
- set集合：集合的三要素
- {} , 无序性、唯一性、确定性
#1.list----列表---有序、异质、根据下标进行查询、更改、删除
#1.1创建
l1=[1,2,3,4]
#1.2查询---根据下标
print(l1[0])
print(l1[1])
#1.3增加
l1.append(10)
print(l1)
#1.4更改
l1[0]="apple"
print(l1)
#1.4删除
del l1[0]
print(l1)
l1.remove(10)
print(l1)
#2.tuple-----元祖-----有序、异质、根据下标进行查询，不能够进行修改、删除、更新等操作
#2.1创建
l2=(1,"apple",3,4)
print(type(l2)) #<class 'tuple'>
#2.2查询
print(l2[0])
print(l2[1])
#2.3修改----不能修改
# l2[0]="apple"
# print(l2) #TypeError: 'tuple' object does not support item assignment
#2.4删除---TypeError: 'tuple' object doesn't support item deletion
# del l2[0]
#可以直接删除整个元祖
# del l2
# print(l2) #NameError: name 'l2' is not defined
#3.dict-----字典-----无序、能够根据key进行查询、更改、删除等操作
#3.1创建
l3={"apple":10,"pear":20}
#3.2查询
print(l3["apple"])
#3.3更改
l3["apple"]="pear"
print(l3)
#3.4删除
del l3["apple"]
print(l3) #{'pear': 20}
l3.clear()
print(l3) #{}
#4.set------集合-----无序性、唯一性、确定性
l4={"apple","pear"}
print({"a","b","c","a","b"})
13.python的list详解
- list列表：有序、异质、根据下标进行查询、更新、删除等操作
- list中各个类型数据的转换
- list()工厂函数转换
- 切片操作----非常重要-----l1[start:stop:step]
# 1.list创建[]及各个数据结构的转换
# list\set\dict\tuple
print(range(10)) # range(0, 10)
print(type(range(10))) # range(0, 10) <class 'range'>
# 在python2中情况
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# <type 'list'>
print(list(range(10))) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# tuple----->list
t1 = (1, 2, 3, 4)
l1 = list(t1)
print(l1)
print(type(l1))
# set----->list
print(list({1, 3, 4})) # [1, 3, 4]
# dict----->list
print(list({"apple": 1, "pear": 2})) # ['apple', 'pear']
print(list({"apple": 1, "pear": 2}.keys())) # ['apple', 'pear']
print(list({"apple": 1, "pear": 2}.values())) # [1, 2]
print(list({"apple": 1, "pear": 2}.items())) # [('apple', 1), ('pear', 2)]
# 2.list的重要的操作---切片操作
l1 = list(range(10)) # l1[start:stop:step]
print(l1[::]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l1[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
print(l1[-2]) #获取倒数第二个
print(l1[2:5:]) # [2, 3, 4] , 最后一个默认步长为1
print(l1[2:5]) # [2, 3, 4]
print(l1[2:]) # [2, 3, 4, 5, 6, 7, 8, 9]
print(l1[::2]) # [0, 2, 4, 6, 8]
print(l1[1::2]) # [1, 3, 5, 7, 9]
# 3.其他补充
print(len(l1))
print([1, 2, 3] + ["one", "A", 'B']) #合并
print(1 in [1, 2, 3]) #True
print(1 not in [1, 2, 3]) #False
# 补充
l1 = list(range(10)) #左闭右开
print(l1) # 0-9 不包含10数值
print(list(range(0, 10, 1)))
14.zip和enumerate函数详解
- zip函数将各个不同组的元素进行组合
- enumerate函数能够完成枚举类型变量输出，对start的值进行调整
#zip函数作用就是将不同组的各个对应元素进行组合
l1=[1,2,3,4]
l2=[1,2,3,4,5,6]
print(list(zip(l1,l2))) #<zip object at 0x0000017EF1A4D448>
# [(1, 1), (2, 2), (3, 3), (4, 4)]
print(list(zip([9,10,11],[1,2,3]))) #<zip object at 0x0000017EF1A4D448>
print(list(zip([9,10,11],[1,2,3],[4,5,6]))) #<zip object at 0x0000017EF1A4D448>
#enumerate函数------枚举
print(list(enumerate(range(10),start=10))) #start代表索引 , 默认从0开始
15.list函数实战
- list的函数—对list的基本操作
- 求长度、最大值、最小值、排序，删除、更改等操作
l1=[1,2,3,4,5]
l2=[6,7,8,9,10]
# 列表操作包含以下函数:
# 1、cmp(list1, list2)：比较两个列表的元素
# print(cmp(l1,l2)) #cmp在python3中已经不存在了
# 2、len(list)：列表元素个数
print(len(l1))
# 3、max(list)：返回列表元素最大值
print(max(l1))
# 4、min(list)：返回列表元素最小值
print(min(l1))
# 5、list(seq)：将元组转换为列表
# 列表操作包含以下方法:
# 1、list.append(obj)：在列表末尾添加新的对象
print(l1) #[1, 2, 3, 4, 5]
l1.append(900)
l1.append(1000)
print(l1)
# 2、list.count(obj)：统计某个元素在列表中出现的次数
print(l1.count(1))
# 3、list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
l1.extend([1,2,3,4,5])
print(l1)
# 4、list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
print(l1.index(1))
# 5、list.insert(index, obj)：将对象插入列表
l1.insert(0,"apple")
print(l1)
# 6、list.pop(obj=list[-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
print(l1.pop())
print(l1.pop())
print(l1.pop())
print(l1.pop())
print(l1.pop())
print(l1.pop())
print(l1.pop())
# 7、list.remove(obj)：移除列表中某个值的第一个匹配项
l1.remove("apple")
print(l1)
# 8、list.reverse()：反向列表中元素
l1.reverse()
print(l1)
# 9、list.sort([func])：对原列表进行排序 ---- 升序
16.tuple操作
- 定义一个只有一个元素的tuple，一定要加逗号，或者通过type查看
- 在tuple中定义list可以直接更改list中各个元素的
- tuple中最重要的操作是切片—重点掌握
#1.定义只有一个元素的tuple
t0=(1)
print(t0)
print(type(t0)) #<class 'int'>
t00=(1,) #必须加逗号
print(type(t00))
#2.如果在tuple中定义一个list，那么list是否可以改变呢？
t01=(1,2,3,["Apple","pear"])
print(t01)
print(t01[0])
print(t01[1])
print(t01[2])
print(t01[3])
print(t01[3][0]) #取index为3的第一个元素
print(t01[3][1])
t01[3][0]="banana"
#(1, 2, 3, ['banana', 'pear'])
print(t01)
#3.tuple与各个数据结构类型的转换
t1=(1,2,3,4)
t2=tuple(range(10))
t3=tuple([1,2,3,4])
t4=tuple({1,2,3,4})
t5=tuple({1:"apple",2:"banana",3:"orange"})
print(t1)
print(t2)
print(t3)
print(t4)
print(t5)
#4.切片操作 , 与list类似
print(t2[::])
print(t2[::-1])
print(t2[1:5:])
print(t2[1:5])
print(t2[:8])
17.dict详解及函数操作
- dict字典
- 创建方式
- dict对象
- { k:v}
- 查询：根据key，但是
key必须唯一，key必须是具备hash值的不可改变类型 - 直接对key进行删除
- 创建方式
- dict函数
- 字典的增删改查、字典的各种函数的实现
#字典的创建形式
c1={"Apple":10,"pear":20}
print(c1)
print(type(c1))
c2=dict(name="zhangsan",age=13)
print(c2)
print(type(c2))
c3=dict(zip(["apple",'pear'],[10,20]))
print(c3)
#字典的查询
phone_book={"Azhangsan":100,"lisi":200,"wangwu":300}
print(phone_book["Azhangsan"])
phone_book["Azhangsan"]=178
print(phone_book)
del phone_book["Azhangsan"]
print(phone_book)
#一个键如果重复两次怎么办？----会覆盖前面的
phone_book={"zhangsan":100,"lis":100,"zhangsan":900}
print(phone_book)
# 如果一个键没有hash值或可改变的类型都不可以作为键
# 因为键需要是唯一的
# print(hash(["zhangsan"])) #TypeError: unhashable type: 'list'
# phone_book={["zhangsan"]:100,"lis":100,"zhangsan":900} #TypeError: unhashable type: 'list'
phone_book={("zhangsan"):100,"lis":100,"zhangsan":900} # 正常打印
dictFunction
d1={1:"Apple",2:"pear"}
d2={3:"Apple",4:"pear"}
print(d1)
print(d2)
# Python字典包含了以下内置函数：cmp存在于Python2中
# 1、cmp(dict1, dict2)：比较两个字典元素。
# cmp(x,y) 如果x<y返回-1 , 如果x==y返回0 , 如果x>y返回1
# print(cmp(d1,d2))
# 2、len(dict)：计算字典元素个数，即键的总数。
print(len(d1))
# 3、str(dict)：输出字典可打印的字符串表示。
s1=str(d1)
print(s1)
# 4、type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型。
# Python字典包含了以下内置方法：
# 1、radiansdict.clear()：删除字典内所有元素
l2={"pple":1}
l2.clear()
print(l2)
# 2、radiansdict.copy()：返回一个字典的浅复制
# 3、radiansdict.fromkeys()：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
# 如：print "fromkeys",dict_2.fromkeys(dict_2,10)
# 4、radiansdict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值
print(d1.get(1))
# 5、radiansdict.has_key(key)：如果键在字典dict里返回true，否则返回false
# print(d1.has_key(1)) # 存在于Python2中
# 6、radiansdict.items()：以列表返回可遍历的(键, 值) 元组数组
print(d1.items())
# 7、radiansdict.keys()：以列表返回一个字典所有的键
print(d1.keys())
# 8、radiansdict.setdefault(key, default=None)：和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
d1.setdefault(1,100)
print(d1)
# 9、radiansdict.update(dict2)：把字典dict2的键/值对更新到dict里
d1.update({"apple":1000,"banana":2000})
print(d1)
# 10、radiansdict.values()：以列表返回字典中的所有值
print(d1.values())
18.set集合详解
- set-确定性、唯一性、无序性
- set的基本创建----{元素}
- set根据update/add/等方法进行更新和增加元素的值
- set作用就是对原有的数据加上set集合去重
- set运算----交并补集
#集合-创建以及各个数据结构的转换
set1={1,2,3,4,5}
set2=set(range(10))
set3=set([1,2,3,4])
set4=set((1,2,3,4))
set5=set({"Apple":1,"pear":2})
print(set1)
print(set2)
print(set3)
print(set4)
print(set5)
#集合的增加元素
set1.add(100)
print(set1)
#集合的删除元素
set1.remove(100)
print(set1)
#集合的更新操作
set1.update({100,200,300})
print(set1)
#集合的运算------交并补
s5={1,2,3,4,5}
s6={4,5,6,7,8}
s7={4,5}
#集合的补集
print(s5-s6)
print(s5.difference(s6))
#集合的交集
print(s5 & s6)
print(s5.intersection(s6))
#集合的并集
print(s5 | s6)
print(s5.union(s6))
#集合和集合的包含运算
print(s7 < s5)
print(s6 < s5)
# 去重
l1=[1,2,3,4,1,2,3,4,5,6,12,3,4]
print(set(l1)) #{1, 2, 3, 4, 5, 6, 12}
19.列表推导式
- 推导式：求解满足条件的列表
- 列表推导式–本质上还是一个列表
- 语法：
[表达式 for 变量 in 序列或迭代对象 if 条件]- 序列或迭代对象指的是list、tuple、dict、set
#1.通过列表表达式将符合条件的列表进行筛选
l1=[x*x for x in range(10) if x>3]
print(l1)
#等价公式
result=[]
for x in range(10):
if x>3:
result.append(x*x)
print(result)
#map函数-----将函数作用于list上
l = [1, 2, 3, 4]
print(type(l))
print(list(map(str, l)))
#Demo2 练习：
freshfruit=['banana','loganberry','passion fruit']
aList3=[]
for item in freshfruit:
aList3.append(item.strip())
print(aList3)
#等同于
aList4=list(map(lambda x:x.strip(),freshfruit))
print(aList4)
#等同于
aList5=list(map(str.strip,freshfruit))
print(aList5)
- 应用场景：
- 使用列表推导式完成矩阵的转置、矩阵元素的平铺
- 使用列表推导式完成不符合条件的元素的过滤等操作
# 1.使用列表推到式实现嵌套列表的平铺（两个for循环） #1, 2, 3,4, 5, 6,7, 8, 9
vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(vec)
#使用列表表达式完成
print([num for elem in vec for num in elem]) #[1, 2, 3, 4, 5, 6, 7, 8, 9]
result=[] #[1, 2, 3, 4, 5, 6, 7, 8, 9]
for elem in vec:
for num in elem:
result.append(num)
print(result)
##2.过滤不符合条件的元素
aList=[1,2,3,4,0,-1,-2,-3]
r=[elem for elem in aList if elem >0] #[1, 2, 3, 4]
print(r)
#等价于
result1=[]
for elem in aList:
if elem>0:
result1.append(elem)
print(result1)
##3.列表推导中使用多个循环实现多序列元素任意的组合，并过滤元素
r2=[(x,y) for x in range(10) for y in range(10) if x!=y]
print(r2)
#等价于
result2=[]
for x in range(10):
for y in range(10):
if x!=y:
result2.append((x,y))
print(result2)
##4.实现列表推到式实现矩阵转置
vec=[[1,2,3],[4,5,6],[7,8,9]] #1,4,7
print(vec)
r3=[[row[i] for row in vec] for i in range(3)]
print(r3)
#zip函数
print(list(map(list,zip([1,2,3],[4,5,6],[7,8,9])))) #[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
##5.使用列表推导生成100以内的所有素数
#素数--只能被1和本身整除的数，1肯定不是素数
r4=[p for p in range(2,101) if 0 not in [p%q for q in range(2,p)]]
print(r4)
import numpy as np
r5=[p for p in range(2,101) if 0 not in [p%q for q in range(2,int(np.sqrt(p))+1)]]
print(r5)
20.几个补充函数理解
- enumeration函数
- zip函数
- map函数
- 将函数作用于序列上
- reduce函数
- 将函数作用于序列上，直接做的是累计求和
- filter函数
- 将函数作用于序列上，求解满足过滤条件的元素
#way1
print(list(map(str,range(3))))
#way2
def add1(X):
return X+5
r1=list(map(add1,range(10)))
print(r1)
#way3
def add2(X,Y):
return X+Y
r2=list(map(add2,range(5),range(5)))
print(r2)
#等同于
print(list(map(lambda x,y:x+y,range(5),range(5,10))))
#等同于
print([add2(x,y) for x,y in zip(range(5),range(5,10))])
#导入reduce函数
from functools import reduce
print(reduce(add2,range(5))) #1+...+5
print(reduce(lambda x,y:x+y,range(5)))
#filter过滤函数
seq1=['foo','x41','?1','***']
def func(x):
return x.isalnum()
filter(func,seq1) #返回filter对象
print(list(filter(func,seq1))) #将filter转化为列表
#使用列表推到式实现相同的功能
print([x for x in seq1 if x.isalnum()])
21.元祖和字典推导式
-
元祖推导式----生成器推导式—求解满足条件的元祖—惰性求值----__next__（）求解
-
字典推导式----求解满足条件的字典----{key:value for key,vaue in zip(xx,xxx)}
-
有序字典
-
from collections import OrderDict dict=OrderDict（） dict["apple"]=1
-
-
ListDerive
#1.通过列表表达式将符合条件的列表进行筛选
l1=[x*x for x in range(10) if x>3]
print(l1)
#等价公式
result=[]
for x in range(10):
if x>3:
result.append(x*x)
print(result)
#map函数-----将函数作用于list上
l = [1, 2, 3, 4]
print(type(l))
print(list(map(str, l)))
#Demo2 练习：
freshfruit=['banana','loganberry','passion fruit']
aList3=[]
for item in freshfruit:
aList3.append(item.strip())
print(aList3)
#等同于
aList4=list(map(lambda x:x.strip(),freshfruit))
print(aList4)
#等同于
aList5=list(map(str.strip,freshfruit))
print(aList5)
- tupleDerive
#元祖--求解满足条件的元祖
#生成器推导式---惰性求值-----
t1=(x*x for x in range(10))
#通过next方法进行求解下一个符合条件的元素
print(t1.__next__()) #求解一个出去一个
print(t1.__next__()) #
print(t1.__next__())
print(t1.__next__())
print(t1.__next__())
print(list(t1)) #
print(list(t1)) #后面的就为空了===>[]
print(list(t1))
#python中可以将多元素赋值叫做序列解包
a,b=1,1
print(a,b)
(x,y,z)=1,2,3
print(x,y,z)
- dictDerive
#符合条件的字典---字典表达式
#1.
print({i:str(i) for i in range(10)})
#2.
x=['A','B','C','D']
y=['a','b','c','d']
e_dict={i:j for i,j in zip(x,y)}
print(e_dict)
#3.有序字典
# 有序字典和通常字典类似，只是它可以记录元素插入其中的顺序，而一般字典是会以任意的顺序迭代的。
# 有序字典可以按字典中元素的插入顺序来输出
# 有序字典一般用于动态添加并需要按添加顺序输出的时候
from collections import OrderedDict
ord1=OrderedDict() #将类初始化为一个对象
ord1["apple"]=1
ord1["pear"]=2
ord1["banana"]=3
print(ord1)
# OrderedDict([('apple', 1), ('pear', 2), ('banana', 3)])
22.扩展-Vscode+Anaconda
- 扩展
- vscode通过配置文件配置环境变量进行python开发
23.总结
扫一扫
2851
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
