python初学

安装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

三种括号的含义 [ ], { }, ( )

1. 中括号[ ]: 匹配 单个字符 是否属于中括号中的一个字符
   字符串: 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 这几个字符
   值得一提, 中括号中的特殊符号也会认为是字符 比如 <>, (), {} 都会被看作字符的括号而非特殊含义,
   ^ - \ 这个三个特殊符号保留特殊含义, 想要匹配^ - \ 则使用^, -, \
2. 大括号{ }, 用于重复次数, 大括号左边表达式的匹配次数
   字符串: hello world!!
   js正则表达式: /l{2}/g
   匹配到的内容是: he ll o world!!
3. a{1, 4} 匹配 a 字符 1 到 4次 如 a aa aaa aaaa
4. [0-9]{3} 匹配连续 3 个数字
5. [a-z]{1,} 匹配小写字母字符 1次到无数次
6. [a-z]{,5} 匹配小写字母字符 最多5次
7. 小括号( ), 表示一个子表达式
   字符串: hello world!!
   js正则表达式: /(ell)/g
   匹配到的内容是: h ell o world!!
   此处注意, 如果字符串是helo 则是匹配不到任何内容的
   小括号中的内容是一个完整的正则表达式
8. (ha){2} 匹配 内容为haha
9. ((ha){2} hello) 匹配到的内容为: haha hello
10. (a | b){2} 能够匹配到的内容为 aa bb ab ba
    子表达式可以很复杂, 这样多个子表达式组合起来, 可以匹配出规则很复杂的字符串
    补充
    (?=), (?!), (?<=), (? 同

正则表达式 4种预查的作用

(?=pattern) (?!pattern) (?<=pattern) (? 刚开始学习正则表达式的时候看着最蒙逼的4个表达式, 小括号中带着问号, 一脸蒙逼不知道是写的
啥, 也没整明白效果是啥. 后来终于在不断的看文档和尝试, 总算是搞明白了
预查表达式
预查表达式主要功能是起到 判断作用 , 类似于编程中的 if 判断语句, 判断当前匹配字符的左右内容是
什么, 并且符合预查表达式内容的内容 不会被获取 .
在我们要匹配一些字符串的时候, 通常有些内容我们不需要匹配获取, 但是可以作为参考, 这个时候就
可以使用预查表达式了. 例: 获取所有 括号之间的内容不包含括号 , 所有 双引号之间的内容 等.
方向
预查表达式可以看到有两个方向, 正向 和 反向. 通俗来说就是 当前字符判断位置 的 右边 和 左边.
4种表达式中 < 用来描述向左(反向), 没有 < 表示向右(正向)
当然这种写法也是固定的, 比如你写个(?<<=)就报错了.
肯定 和 否定
肯定用 = 号描述, 否定用 ! 号描述
这两种含义最简单的理解就是 是 和 不是
bcd(?=123) 表示 获取 bcd 字符串并且该字符串右边一定是 123 字符串.
能匹配到bcd123
bcd(?!123) 表示 获取 bcd 字符串, 并且该字符串右边一定不是 123
所以匹配到的内容一定不是bcd123, 可以是bcdasd, bcdbcd, bcd123… 反正bcd右边不是123的
都行
各种刁钻的例子

1. (?=abc)a 表示 获取 a 字符串, 并且从a字符串左边开始向右 为 abc
   等统于 a(?=bc), 因为是从a字符左边开始向右, 所以会包含a字符.
2. (?<=123)abc 表示 获取字符串abc, 并且abc字符串的左边一定是123字符串
3. abc(?<=123) 表示 获取字符串abc,并且从c字符右侧向左3个字符的字符串一定是123
   因为c字符右侧开始向左3个字符和abc重叠了, 所以这个是表达式匹配不到任何字符串.
4. (?<=123)abc 表示 获取字符串abc, 并且从字符a左边开始向左3个字符一定是123.
   字符串123abc 满足条件匹配成功, 并获取到的字符串是abc
   正常一点的例子
5. (?<= ).)*(?=)) 获取所有小括号中的内容
   字符串 (aa)test(bb)test2(cc)test3(dd) 获得内容为4个字符串 aa bb cc dd
6. (?<=“)\w*(?=”) 获取双引号之间的字符串