【paddle领航团基础python课程】

python的应用领域

  • Web应用开发
  • 自动化运维
  • 3D游戏开发
  • 图形界面开发
  • C/S服务端开发
  • 科学计算

Python的特点

  • 简洁性 实现同样的功能,python代码的行数往往是Java的1/5;
  • 易读性
  • 可扩展开源性

python运算符优先级

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ThAt64KB-1613528131701)(C:\Users\fylal\AppData\Roaming\Typora\typora-user-images\image-20210208104803672.png)]

基本数据类型

  • 整型
  • 浮点型
  • 字符串 单引号‘ ’或者双引号“ ”括起来的任意文本 也可以三单引号‘’‘ ’‘’和三双引号“”“ ”“”, 三引号的内容可换行,单或双引号的内容不可换行
  • bool型 True or Flase
  • None 空值

类型转换

  • int() 将float型,string型,bool型转为整型
  • str() 将int型,float型,bool型转为整型
  • bool() 非零为True,0为False
  • float 将将int型,string型,bool型转为整型

基本运算符

print(1+2)   # 加法
print(1-2)   # 减法
print(1*2)   # 乘法
print(1/2)   # 除法
print(1//2)  # 整除 (向下取整)
print(1%2)   # 取余数
print(2**2)  # 幂运算

起名法则

标识符由字母,下划线,数字组成,标识符第一个字符不能为数字。

注意:标识符命名不能和关键字名字一样

查看关键字方法:

import keyword
print(keyword.kwlist)

组合数据类型

  • 列表 list

list是一种有序的组合,可以随时添加和删除其中的元素。

列表的创建方式:

  • 使用中括号
  • 调用内置函数list()
list1=[1,2,3,4,5]
list2=['a','b','c','d','a']
list3=['a','d',1,2]
len(list1)   # 求list1的长度
list1[4]     # 取list1下标为4的数,下标从0开始正着数或者从-1倒着数
#********list常用函数***********
list3.append(3) # 在list3的后面添加数字3
# 删除元素
list1.pop()  # 默认弹出最后一个数字,list1的长度减1
list1.pop(4) # 将list1中的下标为4的数弹出
list2.remove('a')    # 移除找到的第一个字符
#切片删除
list2[1:2]=[]
# 插入元素
list2.insert(2, 'ooo')  # 在指定位置添加元素,如果指定的下标不存在,那么就是在末尾添加
# count计数和index查找
print(list2.count('a'))
print(list.index('a'))
print(list2)
#合并list1和list2
list1.extend(list2)   # 合并两个list,list2中仍有元素
#在任意的位置上添加多个元素
list1[1:]=list3
#将列表对象删除
del list1
#修改列表当中的多个值
list2[1:3]=[1,2,3,4,5,6]

list索引、切片

list1 = ['a','b','c','d','e','f']
list1[2]
list1[2:5]

列表的排序

  • 调用sort()方法,列表中的所有元素默认从小到大的顺序进行排列,可以指定reverse=True进行降序或升序,原列表改变
  • 调用内置函数sorted(),可以指定reverse=True,进行降序排序,产生新的列表对象
list1.sort(reverse=True)
new_list=sorted(list1,reverse=False)
  • 元组 tuple

另一种有序列表,tuple和list类似,但tuple一旦初始化就不能修改,无append()、pop()函数,是不可变序列

元组的创建方式

  • 直接小括号
  • 使用内置函数tuple
  • 若元组中只包含一个元素,需要用逗号和小括号,如t=(10,)

元组的遍历

  • 利用索引

  • 元组是可迭代对象,可使用for…in进行遍历

t=tuple(('python','hello',90))
for item in t:
	print(item)
tuple1=(1,2,3,4,5)
tuple2=('a','b','c','d')
tuple3=('a','d',1,2)
tuple4=tuple(1,2,3,4)
tuple5=tuple(('python',2,3,4)
tuple6='python',2,3,4   
#空元组
t7=()
t8=tuple()
len(tuple1)

  • 字典 dict

dict全程dictionary,使用key-value存储,具有极快的查找速度。

是一个无序(无索引位置)可变序列

字典的创建方式:

  • 使用花括号:{key:value}
  • 使用内置函数dict(),dict(name=‘jack’,age=20) #等号左边是key,右边是value

获取字典的元素

  • 使用[]

  • 使用get方法

    区别:如果查找键不存在,[]提示报错,而get输出None,不存在时可设置默认值,如print(scores.get(‘小王’,90)) #返回90

获取字典试图的三个方法

  • keys():获取字典中所有key
  • values():获取字典中所有value
  • items():获取字典中所有key,value对

字典元素的遍历

for item in word:
    print(item)        #返回键
    print(word[item])  #返回键所对应的值
    print(word.get(item))  #返回键所对应的值

字典的特点:

  • key不能重复,是不可变对象,如key不能为列表
  • value能重复

字典生成式:

  • 内置函数zip()

    用于将可迭代的对象作为参数,将对象中对应元素打包成一个元组,然后返回由这些元组组成的列表

    items=['Fruist','Books','Others']
    princes=[96,78,85]
    lst=zip(items,princes)
    print(list(lst))
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U7vR3v5a-1613528131706)(C:\Users\fylal\AppData\Roaming\Typora\typora-user-images\image-20210212181057627.png)]

word = {'apple':'苹果','banana':'香蕉'}
scores = {'小张':100, '小李':80}
grad = {4:'很好',3: '好',2:'中',1:'差',0:'很差'}
scores['小张']
grad[3]
scores['小赵']=60  # 查找字典中是否有小赵,无就添加,有就修改
print(scores.get('小张'))
#删除字典中的key-value
del scores['小张']
#清空字典的元素
scores.clear()
print(scores.key())
  • 集合 set

set和dict类似,是一组key的集合,但不存储value。且key不能重复。

集合生成式,将方括号改为花括号

{i*i for i in range(6)}

集合的相关操作

s={1,1,2,3,4}  # 输出:{1,2,3,4}
print(6 in s)   #False
#集合元素的添加操作
s.add(100)   #一次添加一个
s.update({200,300,400})  #一次至少添加一个
s.update((7,8,9))
#集合元素的删除操作
s.remove(100)  #存在即抛出,不存在抛出异常
s.discard(600)   #不做操作
s.pop()    #不能有参数
s.pop(1)  #错误
s.clear()  #清空集合
s1=set(range(6))
# 类型转换
set([1,1,2,3,4])  # 列表→集合
list({1,1,2,3,4}) # 集合→列表
list((1,2,3))     # 元组→列表
#定义空集合
s=set()
#判断集合是否相等
print(s==s1)
#一个集合是否是另一个集合的子集
print(s1.issubset(s))
#一个集合是否是另一个集合的超集
print(s1.issuperset(s))
#两个集合是否含有交集
print(s1.isdisjoint(s))  #有交集为False
#两个集合的交集
print(s1.intersection(s))
print(s1&s)
#并集操作
print(s1.union(s))
print(s1|s)
#差集操作
print(s1.difference(s))
print(s1-s)
#对称差集
print(s1.symmetric_difference(s))
print(s1^s)

流程控制:条件判断和循环

  • if语句

    if 条件:
       语句
    else:
    

    多重条件语句

    if 条件:
       语句
    elif 条件:
       语句
    else:
        语句
    

    例子:

    score = 80
    if score < 60:
        print('不及格')
    else:
        print('及格')
    
  • while

    number = 1
    while number<10:   # 注意边界条件
        print(number)
        number+=1
    
  • for循环

    for循环可以遍历任何序列的项目,如一个列表或者一个字符串

# 打印1到9
for i in range(9):
    print(i+1)
    
fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        
   print( '当前水果 :', fruit)

for letter in 'Python':     # 第二个实例
   print( '当前字母 :', letter)
  • for循环扩展

    对list_1操作,对每一个数加1

    #方法一:
    list_1=[1,2,3,4,5]
    list_2=[]
    for i in range(len(list_1)):
        list_2[i]+=1
    print(list_2)
    
    #方法二:
    list_2=[n+1 for n in list_1]
    print(list_2)
    
    
    

    判断list_1中的奇数

    #方法一:
    for i in range(len(list_1)):
        if list_1[i]%2==1:
            list_2.append(list_1[i])
    print(list_2)
    #方法二:
    list_2=[n for n in list_1 if n%2==1]
    

    在list_A 但是不在list_B中

    list_A = [1,3,6,7,32,65,12]
    list_B = [2,6,3,5,12]
    [n for n in list_A for n not in list_B
    
  • break vs continue

    使用break语句来完全终止循环

    使用continue语句直接跳到循环的下一次迭代

    例子:

    # 查找list_1 中的数字
    list_1 = [1,6,3,2,8,4]
    for number in list_1:
        if number == 3:
            print('找到了!')
            break  
            
    # 打印1-10中的偶数 
    for i in range(10):
        num = i+1
        if num%2 == 0:
            print(num)
        else:
            continue
    

字符串进阶

  • 字符串索引、切片

    切片:[起始:结束:步长],默认值:截取方向为从左往右,起始为0,结束为字符串结尾元素,步长为1。切片范围为左闭右开。包含左范围,不包含有范围。

    注:当步长为-1时,截取方向为从右往左

    name = 'hello world!'
    name[1]  
    name[-4]     # 结果为r
    name[1:4]    # 结果为ell
    name[::-1]   # 结果为!dlrow olleh
    name[3:]     # 结果为lo world!
    name[8:2:-1] # 结果为row ol
    
  • 字符串常用函数

    count 计数功能

    my_string = 'hello_world'
    my_string.count('o')
    # 查看帮助
    help(my_string.count)
    

    find 查找功能

    返回从左第一个指定字符的索引,找不到返回-1

    my_string = 'hello_world'
    my_string.find('o')    # 查找字符串第一次出现的位置,不存在,返回-1
    my_string.rfind('o')  #查找字符串最后一次出现的位置
    
  
`index 查找`
  
返回从左第一个指定字符的索引,找不到报错
  
  ```python
  my_string = 'hello_world'
  my_string.index('o') #查找字符串第一次出现的位置,不存在,抛出异常
my_string.rindex('o') #查找字符串第一次出现的位置,不存在,抛出异常
  

以某字符开头或结尾startswith()、endswith()

my_string = 'hello_world'
my_string.startswith('hello')  # 是否以hello开始
my_string.endswith('world')   # 是否以world结尾

split 字符串的拆分

按照指定的内容进行分割

my_string = 'hello_world'
my_string.split('_')

字符串的替换

从左到右替换指定的元素,可以指定替换的个数,默认全部替换

my_string = 'hello_world_world_world'
my_string.replace('_',' ')
my_string.replace('world','world'.upper(),2)  # 换前两个
#将列表或元组中的字符串合并成一个字符串
lst=['hello','java','python']
print('|'.join(lst))
t=('hello','java','python')
print(''.join(t))

字符串标准化

默认去除两边的空格、换行符之类的,去除内容可以指定,从字符串的左边开始劈分,默认劈分字符是空格,返回值是一个列表,可通过参数sep指定劈分符,maxsplit指定最大劈分次数。

my_string = ' hello world\n'
my_string.strip()  # 结果为hello world,
s='hello|world|python'
print(my_string.split())  #从字符串左边开始分割
print(s.split(sep='|'))
print(s.split(sep='|',maxsplit=1))
print(s.split(sep='|'))
print(my_string.rsplit())  #从字符串右边开始分割
#右分割同左分割,方向相反

字符串的大小写转换操作

upper() #把字符串中所有字符都转成大写字母

lower() #把字符串中所有字符都转成小写字母

swapcase() # 把字符串中所有大写字符转为小写,小写转为大写

capitalize() #把第一个字符转换为大写,把其余字符转换为大写

title() #把每个单词的第一个字符转换为大写,每个单词的剩余字符转换为小写

字符串的变形

my_string = 'hello_world'   
my_string.upper()  # 所有字母大写
my_string.lower()  # 所有字母小写
my_string.capitalize() # 首字母大写

字符串的原始值显示

print(ord('a'))   #97
print(chr(97))    #a

字符串切片

s='hello,python'
s1=s[:5]   #切片结果不包括5
s2=s[-6::1]	#切到字符串最后一个位置,同列表
s3='!'
newstr=s1+s2+s3

字符串的格式化输出

%

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EtXHU14N-1613528131712)(C:\Users\fylal\AppData\Roaming\Typora\typora-user-images\image-20210208121022991.png)]

accuracy=80/123
print('我的模型正确率为',accuracy,'!')

accuracy=80/123
print('我的模型正确率为%s' %accuracy)

name='Merry'
hight=170
score_math=95
score_english=89
print('大家好!我叫%s,我的身高是%d cm,数学成绩%.2f分,英语成绩%d分' %(name,hight,score_math,score_english))

format

指定了:s,则只能穿字符串值,如果传其他类型值不会自动转换

当不指定类型时,可以传任何类型

print('大家好!,我叫{:s},我的身高是{:d}cm,数学成绩{:.2f}分,英语成绩{}分'.format(name,int(hight),score_math,score_english))

print('Hello,{0},成绩提升了{1:0.1f},百分比{2:0.1f}%'\
     .format('小明',6,80.5))

print('Hello,{name:},成绩提升了{score:.1f}分,百分比为{percent:.2f}%'.format(name='小明',score=6,percent=80.5))

f-string

name='Merry'
hight=170.5
score_math=95
score_english=89
print(f"大家好!我叫{name},我的身高{hight:.3f}cm,数学成绩{score_math}分,英语成绩{score_english}分")

字符串的编码与解码

str='你好呀!'
print(s.encode(encoding='GBK'))  #一个中文占两个字节
print(s.encode(encoding='UTF-8'))  #一个中文占三个字节
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))  #解码编码格式必须与编码相同

函数的创建和调用

  • 函数的创建

    def 函数名([输入参数]):

    ​ 函数体

    ​ return xxx

  • 函数的调用

    函数名([实际参数])

  • 函数传参

    如果参数是不可变对象,则形参不会改变实参的值

    如果参数为可变对象,如列表,则形参的值会改变实参。

    def fun(arg1, arg2):
        print(arg1)
        print(arg2)
        arg1=100
        arg2.append(10)
        print('arg1',arg1)
        print('arg2',arg2)
    
    n1=10
    n2=[1,2,3]
    n=fun(n1,n2)
    print('n1',n1)
    print('n2',n2)
    
  • 函数返回值

    当函数有多个返回值时,结果为元组

    def Num(num):
        odd=[]
        even=[]
        for i in num:
            if i%2:
                odd.append(i)
            else:
                even.append(i)
        return odd,even
    list=[1,2,3,4,5,6,7,8,9]
    print(Num(list))
    #结果:([1, 3, 5, 7, 9], [2, 4, 6, 8])
    
  • 函数的参数定义

    • 函数定义默认值参数

      函数定义时,给形参设置默认值,只有与默认值不符的时候才需要传递实参

def fun(a,b=10):
    print(a+b)
sum=fun(20)
#结果:30
    • 个数可变的位置参数(在函数定义中只能有一个)

      • 定义函数时,可能无法事先确定传递的位置参数的个数,使用可变位置参数
      • 使用*定义个数可变的位置参数
      • 结果为一个元组
      def fun(*args):
          print(args)
      fun(10)
      fun(10,20,30)
      
    • 个数可变的关键字形参(在函数定义中只能有一个)
      • 定义函数时,无法事先确定传递的关键字实参的个数,使用可变的关键字形参
      • 使用**定义个数可变的关键字形参
      • 结果为一个字典
def fun(**args):
    print(args)
fun(a=10)
fun(a=10,b=20,c=30)

函数定义过程当中,参数的顺序:常规形参→位置可变参数→关键字可变的参数

若要将列表中的每一个数传递给函数定义时的参数,则需要将列表转化为位置实参

若要将字典中的每一个数传递给函数定义时的参数,则需要将列表转化为关键字实参

def fun(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
   lst=[10,20,30]
fun(lst)    #出错
fun(*lst)	#转化为位置实参
dic={'a':11,'c'=12,'d':13}
fun(dic)	#出错
fun(**dic)	#转化为关键字实参
fun

函数定义时形参的顺序

def fun(a,b,*,c,d,**args):
    pass
def fun1(*args,**args1):
    pass
def fun2(a,b=10,*args,**args2):
    pass
  • 变量的作用域

    局部变量:在函数内定义并使用的变量,只在函数内部有效,若要变全局变量,需使用global声明

    全局变量:函数体外定义的变量,可作用于函数内外。

  • 递归函数

    • 含义:如果在一个函数的函数体内调用了该函数本身,这个函数就称为递归函数

    • 组成部分:递归调用与递归终止条件

    • 调用过程:每递归调用一次函数,都会在栈内存分配一个栈帧;每执行完一次函数,都会释放相应的空间。

    • 优缺点:缺点:占用内存多,效率低下;有点:思路和代码简单

  • python异常处理机制

    try:
        ...  #可能会出异常的代码
        ...
    except  xxx(异常类型):
        ... #异常处理代码,报错后执行的代码
    
    • 多个except结构

    捕获异常的顺序按照先子类后父类顺序

    try:
        ...  #可能会出异常的代码
        ...
    except  Exception1(异常类型):
        ... #异常处理代码,报错后执行的代码
    except  Exception2:
        ...
    except BaseException:
        ...
    
    • try…except…else结构

      如果try中没有抛出异常,则执行else块,如果有异常,则执行except块

try:
    ...  #可能会出异常的代码
    ...
except  xxx(异常类型):
    ... #异常处理代码,报错后执行的代码
else:
    ...
    • try…except…else…finally结构

finally块无论是否发生异常都会被执行,能常用来释放try块中申请的资源。

使用traceback模块打印异常信息

import traceback
try:
    num=10/0
except:
    traceback.print_exe()

面向对象和面向过程:

面向过程:如做煎蛋,需要一步一步的来,准备鸡蛋,油等…

面向对象:如:直接在美团上点外卖就行

面向对象:宏观;面向过程:微观

类:

类的组成:

(1)类属性:直接写在类里面的变量,称为类属性

(2)实例方法:类里面定义的函数

(3)静态方法:用@staticmethod修饰的叫静态方法,静态方法中不允许有self

(4)类方法:用@calssmethod修饰的叫类方法,类方法中要有一个cls默认参数

初始化方法:

class Student:     #类名:首字母得大写
    place='云南'    #实例属性
  #初始化方法
	def __init__(self,name,age):
        self.name=name	#实体属性
        self.age=age
  #实例化方法
	def eat(self):
        print('学生在吃饭...')
 #静态方法
	@staticmethod
    def method():
        print('使用了静态方法')
#类方法
	@classmethod
    def cm(cls):
        print('使用了类方法')

对象的创建又称类名的实例化

stu1=Student('张三'20)
print(stu1.name)
#调用类中方法:
stu1.eat()
#或
Student.eat(stu1)

类的使用方式:

#类属性使用方式
print(stu1.place)
#或
print(Student.place)
#修改
Student.place='四川'
#类方法使用方式   直接用类名调用
Student.cm()
#静态方法使用方式 直接用类名调用
Student.method()

动态绑定属性和方法

stu2=Student('李四'30)
#动态绑定属性 stu1有这个属性,stu2没有这个属性
stu1.gender='男'
#动态绑定方法
def show():
    print('定义在类之外的,称函数')
stu1.show=show 
stu1.show()

面向对象的三大特征

(1)封装:将属性和方法包装到类对象中。属性和方法私有:在方法名和属性名前加“__“两根下划线

(2)继承:提高代码的复用性

(3)多态:提高程序的可扩展性和可维护性

继承

  • 语法格式

    class 子类类名(父类1,父类2...):
        pass
    
  • 如果一个类没有继承任何类,则默认继承object

  • python支持多继承

  • 定义子类时,必须在其构造函数中调用父类的构造函数

class Person(object):    #父类的object可写可不写
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)
class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no
    def info(self):
        super().info()
        print('学号:',self.stu_no)
class Teacher(Person):
    def __init__(self,name,age,teach_year):
        super().__init__(name,age)
        self,teach_year=teach_year
stu=student('张三'20,’10001)
teacher=Teacher('李四'3410)
stu.info()  #调用重写的方法
teacher.info()  #调用父类的方法

方法重写

如果子类对继承自父类的某个属性或方法不满意,可以在子类中对其进行重新编写。

子类重写后的方法可以通过super().xxx()调用父类中被重写的方法

object类

  • object类是所有类的父类。
  • 内置函数dir()可以查看指定对象所有属性
  • Object有一个__ str __()方法,用于返回一个对于”对象的描述“。
class Student:
    def __init__(self,name,age):
        self.name-name
        self.age=age
    def __str__(self):
        return '我的名字是'.format(self.name,self.age)
stu=student('张三'20)
print(dir(stu))
print(stu)      #默认调用__str__方法

多态

特殊属性和方法

#特殊属性
print(stu1.__dict__)
print(Student.__dict__)
print(stu1.__class__)  #输出对象所属的类
print(Student.__bases__)  #Student类的父类类型的元素
print(Student.__base__)  #输出最近的父类
print(Student.__mro__)	#类的层次结构
print(Student.__subclasses__())  #求子类列表
#特殊方法
a=20
b=100
print(a+b)
print(a.__add__(b))  #结果一样
class Student:
    def __init__(self,name):
        self.name=name
    def __add__(self,other):
        return self.name+other.name
    def __len__(self):
        return self.name
stu1=Student('张三')
stu1=Student('李四')
print(stu1+stu2)
#或
stu1.__add__(stu2)

模块

  • 模块英文:Modules

  • 函数与模块的关系:一个模块中包含N多个模块

  • 在Python中,一个扩展名为.py的文件就是一个模块

  • 模块的好处:

    方便其他程序和脚本导入并使用

    避免函数名与变量名冲突

    提高代码的可维护性

    提高代码的可重复性

自定义模块

  • 创建模块

    新建一个.py文件,名称尽量不要与Python自带的标准模块名称相同

  • 导入模块

import 模块名称 [as 别名]
from 模块名称 import 函数/变量/

自定义模块

# calc.py
def add(a,b):
    return a+b

# example.py
import calc  #此处若报错,则点击文件夹右键Make Directory as中的sources Root
print(calc.add(10,20))
#或者
from calc import add
print(add(10,20))

以主程序形式运行

#calc.py
def add(a,b):
    return a+b
if __name__=='__main__':  #只有当点击calc.py时,才会执行此句语句
    print(add(10,20))
    
#example.py
from calc import add
print(add(100,20))   #结果:120

Python中的包

  • 包是一个分层次的目录结构,它将一组功能相近的模块组织在一个包下

  • 作用:

    代码规范

    避免模块名称冲突

  • 包与目录的区别

    包含__ init __.py文件的目录称为包

    目录里通常不包含__ init __.py文件

  • 包的导入

    import 包名.模块名 [as 别名]
    

    注意:

    使用import导入时,只能是包名或者模块名

    使用from…import导入时,可以是模块名,也可以是函数名

    import 包名
    import 模块名
    from 包名 import 模块名
    from 包名.模块名 import 函数名
    from 模块名 import 函数名
    

Python中常用的内置模块

import sys
import time
import urllib.request   #爬虫时会使用
print(sys.getsizeof(24))  #获取对象所占大小
print(time.time())
print(time.localtime(time.time()))
print(urllib.request.urlopen('http://www.baidu.com').read())

编码格式

Python的解释器使用的是Unicode(内存)

.py文件在磁盘上使用UTF-8存储(外存)

python文件默认为UTF-8

若要修改,在文件开头加上#encoding:dbk/utf-8…

文件的读写原理

  • 文件的读写俗称”IO操作“

  • 内置函数open()创建文件对象

    file=open('a.txt','r')
    print(file.readlines())  #生成列表
    file.close()
    
  • 文件的类型

    • 文本文件:存储的是普通”字符“文本,默认unicode字符集,可使用记事本打开。
    • 二进制文件:以”字节”进行存储,无法用记事本打开,如:MP3音频文件,jpg图片
file=open('b.txt','w')
file.write('Python') #生成列表
file.close()
file=open('b.txt','a')
file.write('Python') #生成列表
file.close()
src_file=open('a.png','rb')
target_file=open('copya.png','wb')
target_file.write(src_file.read())
target_file.close()
src_file.close()
  • 文件对象的常用方法

  • with语句(上下文管理器)

    with语句可以自动管理上下文资源,不论什么原因跳出with块,都能确保文件正确的关闭,以此来达到释放资源的目的。

  • os模块,与操作系统相关的一个模块

import os
os.system('calc.exe')
#直接调用可执行文件
os.startfile('C:\\Program Files\\Microsoft Office\\root\\Office16\\EXCEL.exe')
  • os模块操作目录相关函数
import os
print(os.getcwd())
print(os.listdir('路径'))
os.mkdir('路径','目录名')
os.mkdirs('A/B/C')  #A里面包含B,B里面包含C
os.rmdir('删除目录')
os.removedies('A/B/C')
os.chdir('更改的路径')
print(os.getcwd())
  • os.path模块操作目录相关函数
import os.path
print(os.path.abspath('文件或目录'))
print(os.path.exists('文件或目录'))
print(os.path.split('路径+文件')) #将文件所在的路径与文件拆分
print(os.path.splitext('文件'))  #将文件与后缀名拆分
print(os.path.basename('路径'))

例子1:获取当前目录下的所有python文件

import os
path=os.getcwd()
lst=os.listdir(path)
for filename in lst:
    if filename.endswith('.py'):
        print(filename)

例子2:递归遍历目录

newdir目录下有1.py、2.py、subdir文件夹,subdir文件夹有sub1.py

import os
path=os.getcwd()
lst_files=os.walk(path)
for dirpath,dirname,filename in lst_files:
    print(dirpath)
    print(dirname)
    print(filename)
    print('---------------')
    for dir in dirname:
        print(os.path.join(dirpath,dir))
        print('----------')
    for file in filename:
        print(os.path.join(dirpath,file))
        print('----------')
            
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是使用PaddlePaddle进行房价预测的Python代码示例: ```python import paddle import paddle.fluid as fluid import numpy as np # 定义房价预测模型 def house_price_predictor(): x = fluid.layers.data(name='x', shape=[1], dtype='float32') y = fluid.layers.data(name='y', shape=[1], dtype='float32') y_predict = fluid.layers.fc(input=x, size=1, act=None) cost = fluid.layers.square_error_cost(input=y_predict, label=y) avg_cost = fluid.layers.mean(cost) return x, y, y_predict, avg_cost # 定义训练函数 def train(): # 定义训练数据 x_data = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype('float32') y_data = np.array([2.0, 4.0, 6.0, 8.0, 10.0]).astype('float32') train_data = np.hstack((x_data.reshape(-1, 1), y_data.reshape(-1, 1))) # 定义模型和损失函数 x, y, y_predict, avg_cost = house_price_predictor() # 定义优化器 optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01) optimizer.minimize(avg_cost) # 创建执行器 place = fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) # 开始训练 for i in range(100): for data in train_data: x_data = np.array(data[0]).astype('float32') y_data = np.array(data[1]).astype('float32') outs = exe.run( feed={'x': x_data, 'y': y_data}, fetch_list=[avg_cost] ) avg_loss = np.mean(outs) print("Epoch %d, Cost %f" % (i, avg_loss)) # 保存模型 fluid.io.save_inference_model( dirname='./model', feeded_var_names=['x'], target_vars=[y_predict], executor=exe ) # 定义预测函数 def predict(): # 创建执行器 place = fluid.CPUPlace() exe = fluid.Executor(place) # 加载模型 [infer_program, feeded_var_names, target_var] = fluid.io.load_inference_model( dirname='./model', executor=exe ) # 进行预测 x_data = np.array([6.0]).astype('float32') results = exe.run( program=infer_program, feed={feeded_var_names[0]: x_data}, fetch_list=target_var ) # 打印预测结果 print("预测房价:%f" % results[0][0]) # 运行训练和预测函数 train() predict() ``` 注意:以上代码仅为示例,实际应用中需要根据数据和需求进行相应的修改和调整。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值