安装anaconda
此模块为转载
https://blog.csdn.net/m0_64892604/article/details/128806043
一、创建虚拟环境
conda create --name env_name
conda create --name env_name python=3.6 # 创建指定python版本
conda create --name env_name python=3.6 pandas numpy scipy # 创建指定python版本下包含某些包
二、激活/使用/进入某个虚拟环境
conda activate env_name
三、退出当前环境
conda deactivate
四、复制某个虚拟环境
conda create --name new_env_name --clone old_env_name
五、删除某个环境
conda remove --name env_name --all
六、查看当前所有环境
conda info --envs 或者 conda env list
七、查看当前虚拟环境下的所有安装包
conda list 需进入该虚拟环境
conda list -n env_name
八、安装或卸载包(进入虚拟环境之后)
conda install requests
conda install xx=版本号 # 指定版本号
conda install xxx -i 源名称或链接 # 指定下载源
conda uninstall xxx
九、分享虚拟环境
conda env export > environment.yml # 导出当前虚拟环境
conda env create -f environment.yml # 创建保存的虚拟环境
十、源服务器管理
conda当前的源设置在$HOME/.condarc中,可通过文本查看器查看或者使用命令>conda config --show-sources查看。
conda config --show-sources #查看当前使用源
conda config --remove channels 源名称或链接 #删除指定源
conda config --add channels 源名称或链接 #添加指定源
例如:
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
国内pip源
阿里云 http://mirrors.aliyun.com/pypi/simple/
中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
豆瓣(douban) http://pypi.douban.com/simple/
清华大学 https://pypi.tuna.tsinghua.edu.cn/simple/
中国科学技术大学 http://pypi.mirrors.ustc.edu.cn/simple/
十一、升级
升级Anaconda需先升级conda
conda update conda
conda update anaconda
十二、卸载
rm -rf anaconda
十三、批量导出虚拟环境中的所有组件
conda list -e > requirements.txt # 导出
conda install --yes --file requirements.txt # 安装
十四、pip批量导出环境中的所有组件
pip freeze > requirements.txt
pip install -r requirements.txt
变量的定义
name = ‘王五’
print(name)
age = 23
print(age)
变量的类型 可以用type查看
print(type(name))
print(‘’‘-------------’‘’)
print(type(age))
#标识符 :只能由字母,数字,下划线组成,数字不能作为开头,在python中是区分大小写的。
#关键字, 在命名时不能和关键字相同
#输出变量
#输出变量
print(‘python程序中输出’)
#输入
password = input(“请输入密码:”)
print(password)
格式化输出
password = input(“请输入密码:”)
print(‘您的密码是:%s’ %password)
t_id = input(“学号:”)
name = input(“姓名:”)
print(‘this student number: %s , name:%s’ %(t_id,name))
number = 1101
print(‘the number is : %d’ %number)
多个变量进行赋值
id,name,age = 1001,‘王五’,20
print(‘id: %d,姓名: %s,年龄:%d’ %(id,name,age))
判断
if else
ticket = 1
if ticket == 1:
print(‘has ticket’)
else :
print(“no ticket”)
elif
score = 70
if score >=90 and score<=100:
print(‘A’)
elif score >=80 and score < 90:
print(‘B’)
elif score >=70 and score <80:
print(‘C’)
while 循环
i = 0
while i< 5 :
print("now i is %d " %(i+1))
print(‘i=%d’ %i)
i+=1
for循环
#需求:将1,2,3,4 进行求和
sum = 0
for i in [1,2,3,4]:
sum+=i
print(‘sum=%d’ %sum)
python3 中提供了range() 返回的是一个可迭代对象(类型是对象),不是列表类型 左闭右开
python2 中返回的实证书列表
range 一般结合 for 进行使用
for i in range(5):
print(i)
breank 提前退出循环
for i in range(6):
print(‘-------’)
if i ==3 :
break
print(i)
continue 结束本次循环,继续下一次循环
字符串
str = ‘hello’
获取字符串中的指定元素 [0]: 代表索引或者下标 [-1] :获取最后一个字符
获取字符串长度 len(str)
字符串的切片
从某个位置截取到某个位置 str[1:5]
从某个位置截取到最后 str[1;]
从开始截取到某个位置 str[:3]
字符串的内置函数
str1 = ‘ll’
find: 检测 str 是否包含 str1 str.find(str1) 如果找到了,返回第一个字符的索引,如果没找到返回 -1
upper: 将字母转化为大写 str.upper()
#lower: 将字母转换为小写 str.lower()
startswith 字符串起始位置是否包含指定字符串
endswith 字符串结束位置是否包含指定字符串
count()统计字符串出现的次数
isdigit 判断是否全是数字
isalpha 判断是否全是字母
isalnum 检测字符串是否包含数字和字母
字符串的遍历
enumerate :将一个可遍历的数据对象(如列表,字符串,元组)组合为一个索引序列,同时返回数据和数据的下标(一般用在for循环)
str = ‘hello’
for index ,value in enumerate(str):
print(index,value)
列表
定义: 是一种有序集合,可以进行添加或者删除,定义的时候方括号之内的,元素之间是用逗号分隔,
列表中的数据类型未必是相同的
listm = [1,1.2,‘abc’,True]
#切片 ,使用切片前后数据类型不改变
print(listm[0:2]) # 左闭右开
#增删改查
#空列表
mylist = list()
#元素的添加
mylist.append(3)
#指定位置插入
mylist.insert(0,‘a’)
#列表合并
mylist1 = [‘c’,‘d’]
mylist.extend(mylist1)
#列表修改
mylist1[0] = 1
#删除指定的数据
mylist1.remove(‘d’)
#删除指定位置的数据
del mylist1[0]
#清空列表
mylist1.clear()
遍历列表
for vlaue in mylist1:
print(value)
判断列表中是否存在某个元素
3 in mylist1
判断列表中是否不存在某个元素
3 not in mylist1
嵌套列表
元组
注意:是不能修改,删除的,元组使用的是小括号,其他的和列表相同
mytuple = (1,2,‘abc’,True)
tuple 中嵌套列表
mytuple = (1,2,[3,4])
可以修改其中列表的值
如果tuple 只有一个元素,需要末尾加上 , tuple1=(1,)
练习小案例
1 ,两数相加
num1 = input(“请输入一个数字:”)
num2 = input(“请输入一个数据:”)
sum = int(num1)+int(num2)
print(‘和:%d’ %sum)
#乘法口诀表
for i in range(1,10):
for j in range(1,i+1):
print('{}*{}={} \t'.format(i,j,i*j) , end ='')
print()
生成随机数
import random
生成0-9的整型随机数
random.randint(0,9)
生成一个0-1之间的浮点随机数
random.random()
字典 : 键值对
mydict = {‘name’:‘wang’,‘age’:22,‘sex’:‘men’}
获取字典中的value
print(mydict[‘name’])
print(mydict.get(‘name’))
创建一个空字典
dict1 = {}
dict2 = dict()
print(dict1)
print(dict2)
添加元素
dict1[‘userName’] = ‘wang’
dict2[“password”] = ‘zi’
修改
dict1[‘userName’] = ‘jian’
删除
mydict.pop(“sex”)
del mydict[‘age’]
清除
mydict.clear()
判断 key 是否在字典中
‘age’ in mydict
获取字典中的所有值
mydict.values()
获取字典中的所有key
mydict.keys()
遍历
for key in mydict:
print(key)
print(mydict[key])
for key,value in mydict:
print(key, value)
集合 set : 无序的不重复的序列
myset = {1,2,4,‘abc’}
#定义空集合
myset2 = set()
集合遍历
集合去重
mylist = [1,1,1,2,2,3,3,3]
myset3 = set(mylist)
print(myset3)
函数: 将独立功能的代码块祖志成一个独立的小模块
语法:
def 函数名 (参数【可选】):
功能代码
pass 表示该函数什么也不做
函数的文档说明
def show(num1):
‘’’
函数的功能:
参数 :
‘’’
print(num1)
help(show)
函数的几种类型
无参数,无返回值
def show():
print(‘hello word’)
有参数没返回值
def show(name,age):
print(name,age)
无参数,有返回值
def show():
str1 = ‘hello world’
return str1
有参数,有返回值
def show(name,age):
str1 = ‘hello %s world %d’ %(name,age)
return str1
注意
#1.两个函数名相同时,下面的函数会覆盖上面的函数
#2,函数名也不要和变量名相同
缺省参数
针对两个数字进行求和
def sum_num (num1,num2):
result = num1+num2
return result
定长参数个数
def sum_num (num1=1,num2=2):
result = num1+num2
return result
print(sum_num(1))
不定长参数: 不定长必选参数, 不定长关键字参数
不定长必选参数 (*args)
def sum_num3(*args):
print(type(args))
result = 0
for value in args: # 遍历元组
result += value
return result
re = sum_num3(2,3,4,5)
print(re)
不定长关键字参数(**kargs)
def sum_num4 (**kargs):
print(type(kargs))
for key,value in kargs.items(): #遍历字典
print(key,value)
sum_num4(num1=1,num2=2)
局部变量: 函数定义在作用域内的变量
和全局变量不同的是作用域的范围
num = 100
def show():
global num #修改全局变量通过 global 关键字
num =10
print(num)
show()
print(num)
匿名函数
使用lambda 关键字定义
#创建 和调用
a,b,c 形式参数
1,2,3 实际参数
result = (lambda a,b,c : a+b+c)(1,2,3)
print(result)
面向对象
类的定义
class Teacher(object):
#定义属性
country = ‘China’
#方法
def show(shef):
print(“Teacher”)
根据类来创建对象
teacher = Teacher()
#获取对象属性
print(teacher.country)
#teacher.show()
#查看 类继承的父类
print(Teacher.base)
通过对象进行动态的属性添加
teacher.name = ‘zs’
teacher.age = 20
修改属性: 前提是有这个属性,没有就是添加属性了
teacher.name = ‘ls’
print(teacher.name,teacher.age)
self
class Cat(object):
def eat(self):
print(‘%s eating’ %self.name)
c1 = Cat()
c1.name = ‘c1’
c1.eat()
init() 初始化
class Teacher(object):
def init(self,name ,age):
self.name = name
self.age = age
def show(self):
print("teacher")
t1 = Teacher(‘zs’,20)
print(t1.name,t1.age)
t1.show()
继承
注意:
1. 如果一个类A中的属性和方法可以复用,则可以通过继承的方式,传递到类B中
2. 类A 就是 基类,即父类,类B就是派生类 ,即子类
#3. 子类可以继承父类的属性和方法
#单继承:子类只继承一个父类
#优点: 子类可以直接使用父类的属性和方法
父类
class Person(object):
def init(self,name ,age):
self.name = name
self.age = age
def show(self):
print(self.name,self.age)
子类
class Student(Person):
pass
stu = Student(‘zs’,20)
print(stu.name,stu.age)
stu.show()
多继承
class A (object):
def show(self):
print(“A”)
class B (object):
def show(self):
print(“B”)
class C (A,B):
pass
c = C()
c.show()
类的执行顺序
print(C.mro())
重写定义: 子类可以继承父类,父类中的方法满足不了子类的需求,可以对父类的方法进行重写
父类
class Person(object):
def init(self,name ,age):
self.name = name
self.age = age
def show(self):
print(self.name,self.age)
子类
class Student(Person):
def init(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def show(self):
print('my name is %s age is %d sex is %s'% (self.name,self.age,self.sex))
pass
stu = Student(‘zs’,20,‘men’)
stu.show()
私有方法 和私有属性
class Student(Person):
def init(self,name,age,sex):
# 公有属性
self.name = name
self.age = age
# 私有属性: 是以两个下划线定义的 __ ,只能在本类内部使用,在类外面不能使用
self.__sex = sex
def show(self):
print('my name is %s age is %d sex is %s'% (self.name,self.age,self.__sex))
stu = Student(‘zs’,20,‘men’)
stu.show()
多态
多态: 不同的子类对象调用相同的父类方法,产生不同的执行结果,优点,增加代码外部的灵活性
多态形成的前提 :1.继承, 2,重写父类方法
#Animal
class Animal(object):
def run(self):
print(“Animal run”)
class Dog(Animal):
def run(self):
print(“Dog run”)
class Cat(Animal):
def run(self):
print(“Cat run”)
def run_two(animal):
animal.run()
animal.run()
dog = Dog()
cat = Cat()
run_two(dog)
run_two(cat)
异常 :程序运行出错,就会向上抛出,直到某个函数可以处理该异常,每种语言都有 try catch
try:
print(num)
except Exception as e:
print(‘有异常出现时执行里面的代码’)
print(e)
print(“不影响后面代码的执行”)
while True:
str1=input(‘number’)
try:
num = int(str1) +1
except Exception as e :
print(‘exception’)
print(‘%qconsole input again’)
else:
print(‘no error’)
finally:
print(‘finally’)
模块: 通俗来讲就是一个 .py 文件,就是一个模块,作用:管理功能代码,在代码里面可以定义变量,函数,类
自定义模块 导入别人或者自己封装好的功能 py文件
import first_module
print(first_module.g_num)
stu = first_module.Student(‘zs’,20)
stu.show_msg()
import first_module
from 模块名 import 方法名,类名
from first_module import show
from first_module import Student
show()
Student(‘ZS’,20)
from 模块名 import * 导入模块下所有的功能代码, 不推荐使用
文件读写
#1.打开文件
#2.对文件进行操作(读,写)
#3,关闭文件
#打开方式
#r: 只读,文件不存在程序会崩溃,出现文件不存在异常
#w:只写,只会讲原来的内容进行覆盖掉,如果文件不存在,会创建一个文件
#a: 追加写入
#b:标识二进制的形式 常用rb: 以二进制方式打开一个文件用于只读, wb: 以二进制方式打开一个文件用于只写
w模式
打开文件
encoding 指定编码格式, win写入是需要指定的,win中默认的是cp936 -》GBK
f = open(“./text.txt”,‘w’,encoding=‘utf-8’)
操作文件
注意: 文件被打开之后,多次写入数据不会覆盖之前的数据
f.write(‘ABC’)
f.write(‘工程师’)
关闭文件
f.close()
给模块起别名
from first_module import show as show_msg
show_msg()
def show():
print(‘hello student’)
show()
r 模式
f = open(‘./text.txt’,‘r’,encoding=‘utf-8’)
读取数据
content = f.read()
关闭
f.close()
a 模式
f = open(‘./text.txt’,‘a’,encoding=‘utf-8’)
f.write(‘bcd’)
f.close()
rb 模式,二进制方式读取
注意:带有b 的模式都是二进制的模式,在这种模式下,不管什么系统,都不要添加encoding参数
f = open(‘./text.txt’,‘rb’)
content = f.read()
print(content,type(content))
对二进制的数据进行 utf-8 解码操作,将bytes类型的数据转换为 str 类型
result = content.decode(‘utf-8’)
print(result)
将str 转换为 bytes编码
print(result.encode(‘utf-8’))
#关闭
f.close()
定义一个列表,并按照降序排序
mylist = [1,4,2,5,6,3,9]
reverse =True 表示降序,不写表示升序
mylist.sort(reverse=True)
print(mylist)
判断是否为偶数
普通函数
def is_os(num):
if num%2==0:
return True
else :
return False
print(is_os(7))
#匿名函数
f = lambda num:True if num %2 ==0 else False
re = f(3)
print(re)
如何使用匿名函数对字典中的列表进行排序
mylist =[{‘name’:‘zs’,‘age’:20},{‘name’:‘ls’,‘age’:10},{‘name’:‘ws’,‘age’:21}]
#mylist.sort(key = lambda item : item[‘age’],reverse=False)
#print(mylist)
#普通函数
def get_value(item):
return item[‘age’]
mylist.sort(key=get_value,reverse=True)
print(mylist)
利用 python 进行文件 拷贝
打开两个文件,源文件 ,目标文件
oldfile = open(‘./source.txt’,‘rb’)
newfile = open(‘./target.txt’,‘wb’)
#文件操作
while True:
filedata = oldfile.read(1024) # 1024: 读取1024字节的数据
# 判断是否读取完成
if len(filedata) == 0:
break
newfile.write(filedata)
关闭文件
oldfile.close()
newfile.close()
定义类class 为Book ,定义 init 函数和自定义函数
class Book(object):
def init(self,name=‘jueji’,price= ‘39’,author =‘gjm’):
self.name = name
self.price = price
self.author =author
def you(self):
print(‘sutdy hard %s book’ %self.name)
def info(self):
print(‘bookname:%s ,jiage: %s , zuozhe: %s’ %(self.name,self.price,self.author))
class BookZi(Book):
pass
fu = Book(“shazi”,“100”,“gjm”)
fu.you()
fu.info()
zi = BookZi(‘ershazi’,“1000”,“gjm”)
zi.info()
使用正则表达式,匹配字符串
import re
str1 = ‘abc 123 def’
^ 表示 开始
\s 表示任意空白或者空格
\d 表示一个数字
\w 表示一个字母
\d{3} 表示三个数字
.* 表示匹配任意
(.*) 表示匹配第几个
$ 表示字符串结束
group() 表示匹配结果 小括号里不写默认是 0 ,如果写了没有会报错
print(re.match('^abc\s\d\d\d\sdef$',str1).group())
print(re.match('^abc\s\d{3}\sdef$',str1).group())
print(re.match('^abc\s.*\sdef$',str1).group())
print(re.match('^abc\s(.*)\sdef$',str1).group(1))
使用正则表达式中 sub 实现获取匹配的字符串,然后追加指定字符
import re
str1 = ‘hello 7709 66 aa 77 student’
+ 表示有多个
\1 表示匹配的第一个结果
r 表示不对任何字符进行转义
content = re.sub(‘(\d+)’,r’\1 789’ , str1)
print(content)
以下部分为转载
https://blog.csdn.net/evehaoeve/article/details/119093894
三种括号的含义 [ ], { }, ( )
- 中括号[ ]: 匹配 单个字符 是否属于中括号中的一个字符
字符串: hello world!!
js正则表达式: /[eor]/g
匹配到的内容是: h e ll o w o r ld
中括号中有两个特殊, 连接符号 - 和 取反符号 ^
连接符 - 根据ASCII表的值 从小到大 中间的范围 (左边ASCII值必须小于右边ASCII的值)
[0-9] 表示 0到9 之间的数 包括 0 和 9
[3-6] 表示 3到6 之间的数 包括 3 和 6
[a-z] 表示 a-z 之间所有的字母 包含 a 和 z
[A-Z] 表示 A-Z 之间所有的字母 包含 A 和 Z
[0-9A-Z] 表示 0 到 9 和 大写A 到 大写 Z 中间所有字符
[!-/] 表示 ASCII 表中 ! 到 / 之间的所有字符 包含 ! 和 / 字符
取反符号 ^ 紧跟在^后的一个字符, 则不匹配
[^a] 表示不匹配 a 字符
[^abc] 表示不匹配 a 字符
[^] 表示不匹配 ^ 和 \ 字符
[^4-5] 表示不匹配 4 到 5 之间的数字包括 4 和 5 也不匹配
[b-d1-3^5] 表示不匹配b c d 1 2 3 5 这几个字符
值得一提, 中括号中的特殊符号也会认为是字符 比如 <>, (), {} 都会被看作字符的括号而非特殊含义,
^ - \ 这个三个特殊符号保留特殊含义, 想要匹配^ - \ 则使用^, -, \ - 大括号{ }, 用于重复次数, 大括号左边表达式的匹配次数
字符串: hello world!!
js正则表达式: /l{2}/g
匹配到的内容是: he ll o world!! - a{1, 4} 匹配 a 字符 1 到 4次 如 a aa aaa aaaa
- [0-9]{3} 匹配连续 3 个数字
- [a-z]{1,} 匹配小写字母字符 1次到无数次
- [a-z]{,5} 匹配小写字母字符 最多5次
- 小括号( ), 表示一个子表达式
字符串: hello world!!
js正则表达式: /(ell)/g
匹配到的内容是: h ell o world!!
此处注意, 如果字符串是helo 则是匹配不到任何内容的
小括号中的内容是一个完整的正则表达式 - (ha){2} 匹配 内容为haha
- ((ha){2} hello) 匹配到的内容为: haha hello
- (a | b){2} 能够匹配到的内容为 aa bb ab ba
子表达式可以很复杂, 这样多个子表达式组合起来, 可以匹配出规则很复杂的字符串
补充
(?=), (?!), (?<=), (?<!) 这四种写法属于含义比较特殊的子表达式, 为预查表达式 和 ( ) 的含义有所不
同
正则表达式 4种预查的作用
(?=pattern) (?!pattern) (?<=pattern) (?<!pattern)
刚开始学习正则表达式的时候看着最蒙逼的4个表达式, 小括号中带着问号, 一脸蒙逼不知道是写的
啥, 也没整明白效果是啥. 后来终于在不断的看文档和尝试, 总算是搞明白了
预查表达式
预查表达式主要功能是起到 判断作用 , 类似于编程中的 if 判断语句, 判断当前匹配字符的左右内容是
什么, 并且符合预查表达式内容的内容 不会被获取 .
在我们要匹配一些字符串的时候, 通常有些内容我们不需要匹配获取, 但是可以作为参考, 这个时候就
可以使用预查表达式了. 例: 获取所有 括号之间的内容不包含括号 , 所有 双引号之间的内容 等.
方向
预查表达式可以看到有两个方向, 正向 和 反向. 通俗来说就是 当前字符判断位置 的 右边 和 左边.
4种表达式中 < 用来描述向左(反向), 没有 < 表示向右(正向)
当然这种写法也是固定的, 比如你写个(?<<=)就报错了.
肯定 和 否定
肯定用 = 号描述, 否定用 ! 号描述
这两种含义最简单的理解就是 是 和 不是
bcd(?=123) 表示 获取 bcd 字符串并且该字符串右边一定是 123 字符串.
能匹配到bcd123
bcd(?!123) 表示 获取 bcd 字符串, 并且该字符串右边一定不是 123
所以匹配到的内容一定不是bcd123, 可以是bcdasd, bcdbcd, bcd123… 反正bcd右边不是123的
都行
各种刁钻的例子
- (?=abc)a 表示 获取 a 字符串, 并且从a字符串左边开始向右 为 abc
等统于 a(?=bc), 因为是从a字符左边开始向右, 所以会包含a字符. - (?<=123)abc 表示 获取字符串abc, 并且abc字符串的左边一定是123字符串
- abc(?<=123) 表示 获取字符串abc,并且从c字符右侧向左3个字符的字符串一定是123
因为c字符右侧开始向左3个字符和abc重叠了, 所以这个是表达式匹配不到任何字符串. - (?<=123)abc 表示 获取字符串abc, 并且从字符a左边开始向左3个字符一定是123.
字符串123abc 满足条件匹配成功, 并获取到的字符串是abc
正常一点的例子 - (?<= ).)*(?=)) 获取所有小括号中的内容
字符串 (aa)test(bb)test2(cc)test3(dd) 获得内容为4个字符串 aa bb cc dd - (?<=“)\w*(?=”) 获取双引号之间的字符串