python第三节课

其他 2020-10-26 09:30:53 阅读次数: 0

python第三节课

切片

抽取对象某部分值

切片原理

（start_index、end_index、step）即（起始，结束，步长）
在这里插入图片描述

切片操作基本表达式：object[start_index : end_index : step]
  • 当start_index省略，默认为起始端
  • 当end_index省略，默认为终止端
  • 当step省略，默认步长为1
test_1 = list(range(10))
test_2 = test_1[:5:]
test_3 = test_1[2::] 
test_4 = test_1[2:7:]
print(test_1)
print(test_2)
print(test_3)
print(test_4)
# 结果是：
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# [0, 1, 2, 3, 4]
# [2, 3, 4, 5, 6, 7, 8, 9]
# [2, 3, 4, 5, 6]
  • 当步长为正，从左往右，当步长为负，从右往左
    注意：
    start和end之间有和step方向一致元素 间隔，否则会切出空列表
test_1 = list(range(10))
test_2 = test_1[1:5:1]
test_3 = test_1[1:5:-1]
test_4 = test_1[5:1:-1] 
print(test_1)
print(test_2)
print(test_3)
print(test_4)

# 结果是：
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# [1, 2, 3, 4]
# []
# [5, 4, 3, 2]

常用切片

test_1 = list(range(10))
# 取奇数
test_2 = test_1[::2]

# 取偶数
test_3 = test_1[1::2]
print(test_1)
print(test_2)
print(test_3)


# 结果是：
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# [0, 2, 4, 6, 8]
# [1, 3, 5, 7, 9]

函数（懒惰是一种美德）

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数基础

函数定义是一条可执行语句，只有被调用的时候才会执行。

def test(xxxx):
    '''
    The function definitions
    '''
    pass
    print('This is test')
    return 0
  • 注意：
  • def 引入一个函数定义。它必须后跟函数名称和带括号的形式参数列表
  • 函数内容以冒号起始，并且缩进。
  • python 只有函数，没有过程，因为即使没写return， 也会返回一个 None
  • return的作用，终止函数并返回一个值，return为0，返回NULL，返回1，为object，>1为一个元祖。
def test():
    '''
    The function definitions
    '''
    pass
    print('This is test')
    return 12
    print('hello')
print(test)
test()
print(test())
# 结果是：
# <function test at 0x00000218AD755828>
# This is test
# This is test
# 12

参数

形参和实参

形参：
形式参数，实际不存在，目的是在函数调用时接收参数，通过别人赋值后才有意义。相当于变量。
实参：
实际参数，在函数调用时传递参数。是一个实际存在的参数，可以是字符串或是数字等

def test(x):
    '''
    累加
    '''
    count = 0
    for i in range(x+1):
        count += i
    print(count)

test(100)
# print(list(range(101)))
# 0+0+1+2+....+100
# 结果是：
# 5050

位置参数和关键字

  • 位置参数

函数的参数在调用时传递数据时，默认是按参数的位置顺序传值，即形参的顺序与实参的顺序逐一对应，这种参数的使用模式称为位置参数。

  • 关键字参数

关键字参数使用可以不按形参的顺序传递实参，系统按形参的名字确认实参传递给哪个参数
默认参数和参数组

def test(x,y):
    print(x)
    print(y)
    
test(1,2)
test(2,1)#位置参数,与形参一一对应
test(y=2,x=1) # 与形参顺序无关

def test(x,y):
    print(x)
    print(y)
    
x = 1
y = 2
test(y=y, x=x)  # 相当于 y=2 x=1
# test(x=2,3) #报错，混合时不能让关键字参数在前面
test(3,y=2)

局部变量和全局变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序内访问。

在def中,我们可以定义一个局部变量,该变量仅仅在函数体中有生存期,出了这个函数体,变量就不能使用了。

def change_number(number):
    print('before number', number)
    number = 123   # 这个函数只在这个函数中生效 
    print('after number', number)

number = 456
change_name(number)
print(number)

# 结果是
# before number 456
# after number 123
# 456

当内部作用域想要修改外部作用域的变量的时候，就可以用到global

number = 100
print('before change', number)
def change_number():
    global number
    number = 200
    print('in the function', number)
change_number()
print('in the global', number)


# 结果为;
# before change 100
# in the function 200
# in the global 200

递归

函数在内部调用自己本身，就是递归。

累加的递归方法

def sum_test(n):
    if n > 0:
        print(n)
        return n + sum_test(n-1)
        
    else:
        return 0

sum_val = sum_test(10)
print(sum_val)

特性

  • 必须有一个明确的结束条件
  • 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
  • 递归执行效率不高，递归层次过多会导致栈溢出

一直累加一个数超过他的范围

def reduce_test(n):
    print(n)
    return reduce_test(n+1)
reduce_test(10)
# maximum recursion depth exceeded while calling a Python object

给定一个范围

def reduce_test(n):
    if n == 100:
        return 0
    else:
        print(n)
        return reduce_test(n+1)
    
reduce_test(1)

阶乘

def fact(n):
    if n ==1:
        return 1   
    return n * fact(n-1)

print(fact(4))

常用内置函数

# abs()函数返回数字的绝对值。
print(abs(-45))         # 45


#  dict()函数用来将元组/列表转换为字典格式。
print(dict(lisi='123465', wangjie='147258'))

# dir()函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。

print(dir()) #  获得当前模块的属性列表

print(dir({
    
    })) #查看字典的方法

 # divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组（商x，余数y）。

print(divmod(10, 3))


# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

list_test = ['lisi', 'centos', 'ubuntu']
print(dict(enumerate(list_test)))


# eval() 函数用来执行一个字符串表达式，并返回表达式的值。 

print(eval('100+200'))


# exec() 执行储存在字符串或文件中的Python语句，相比于eval，exec可以执行更复杂的Python代码。 
exec("print('hello world')")

 # id()函数用于获取对象的内存地址。
print(id(list_test))

 # len() 方法返回对象（字符、列表、元组等）长度或元素个数。
print(len(list_test))

# max()函数返回给定参数的最大值，参数可以为序列。
print('max(30,4,0):', max(30,4,0))


# min()函数返回给定参数的最小值，参数可以为序列。
print('min(30,4,0):', min(30,4,0))

 # pow()函数返回x的y次方的值。
print(pow(3,2))

 # range() 函数可创建一个整数列表
for i in range(10):
    print(i)
    
 # round() 方法返回浮点数x的四舍五入值。
print(round(4.99))

# sorted() 函数对所有可迭代的对象进行排序（默认升序）操作。

print(sorted([1,5,6,2,7,10]))

# str() 函数将对象转化为string格式。
a = 1
print(type(a))
a = str(a)
print(type(a))
 # sum()函数对参数进行求和计算。
print(sum([1,2,3,4,]))

模块导入

模块的定义

随着程序代码写的越来越多，在一个文件中的代码就会越来越长，维护性会变差，这样我们未来提高代码的维护性和避免函数命名的冲突我们使用模块。

# hello_a.py
def hello():
	print('hello_a')

# hello_b.py
import hello_a
def hello():
	print('hello_b')
	hello_a.hello()
# 如果连续又两个命名一样的函数，最新的会覆盖上一个函数的 内容。
  • 模块分三类
  • 内置标准模块
  • 第三方开源模块，可通过pip install 安装的
  • 自定义模块

自定义模块

模块是一个 以 .py 结尾的Python 文件，用来从逻辑上组织代码（变量， 函数， 类， 功能）
import 的本质就是路径搜索

  • 在当前目录，即当前执行的程序文件所在目录下查找；
  • 到 PYTHONPATH（环境变量）下的每个目录中查找；
  • 到 Python 默认的安装目录下查找。
    在这里插入图片描述

如果没有找到则为异常抛出（ModuleNotFoundError）

导入方法

  • import
import sys, os
  • from … import …
from time import *
  • 最简单的导入
  1. 新建一个文件夹
  2. 创建两个.py的文件相互导入。

在这里插入图片描述

# module01
name = '大司马'

# 01-import导入.py
import module01
print(module01.name)
# 结果为：
# 大司马
  • 倘若没有在路径中，我们添加目录
    module2.py
import os
name = 'pdd'
print(os.getcwd())

import sys
sys.path.append('C:/Users/JOKER/学习python/第一阶段/D4import/test')
# sys.path.insert(0, 'C:/Users/JOKER/学习python/第一阶段/D4import/test')
# 插入第一个位置
import module2
print(module2.name)
  • _变量名使用 from xxx import * 不能被导入
  • 注意：仅仅只限制于不能用from xxx import *
# module01
name = '大司马'
_age = 18
# 私有化处理
# 如果模块中的变量不希望被其他模块以 from import导入可以再变量名前加_表示私有

from module01 import *


print(name)
print(_age)

from module01 import _age

print(_age)

在这里插入图片描述
在这里插入图片描述

  • 两者的区别
  • 调用区别
  •  使用import时：模块名.变量/函数
 使用 from xxx import 时：变量名/函数/类
  • 底层区别
  •  import：直接引用了导入模块的变量
 from xxx import ：直接拷贝了模块资源

- 当多个模块使用一个模块的中间变量用import

main.py

from send import *
from show import *


def main():
    # send()发工资
    send()
    # show()显示工资到账
    show()
    
    
if __name__ == '__main__':
    main()

send.py

import salary

def send():
    print('工资已发送') 
    salary.have_salary = True

show.py

import salary

def show():
    if salary.have_salary == True:
        print('工资已到账')
    else:
        print('待发送')

salary.py

have_salary = False
  • 方法二
from girl import *
def send():
    print('工资已发送') 
    have_salary = True

from girl import *

def show():
    if have_salary == True:
        print('工资已到账')
    else:
        print('待发送')

分别的结果

# 方法一
工资已发送
工资已到账

#方法二
工资已发送
待发送

- 常用模块
os

import os

# 当前Python脚本工作的目录路径：
# print(os.getcwd())
# C:\Users\JOKER\学习python\第一阶段\D4import


# print(os.listdir('C:/Users/JOKER/学习python/第一阶段'))
# 返回指定目录下的所有文件和目录名

# os.remove(path)
# 删除一个文件


# os.removedirs(name)
# 删除多个文件

# os.path.isfile() # 检测是否为文件
# os.path.isdir() # 检测是否为目录

# os.path.exists() # 检测是否存在

# print(os.path.split(os.getcwd()))
# ('C:\\Users\\JOKER\\学习python\\第一阶段', 'D4import')
# 形成一个元祖，分别为上一级，和当前文件

# print(os.path.splitext('C:/Users/JOKER/学习python/第一阶段'))


# print(os.path.abspath(os.getcwd())) # 获取绝对路径
# print(os.path.dirname(os.getcwd())) # 获取路径名
# print(__file__)
# 打印当前程序的路径，包含文件名

# print(os.path.basename(os.getcwd())) # 获取文件名

# os.system('ipconfig') # 运行shell脚本命令

# 重命名
# os.rename(old, new)

# os.makedirs(r"C:\Users\JOKER\学习python\第一阶段\day05") # 创建多级目录
# os.mkdir('test_test') # 创建单个目录

sys

import sys

print(sys.version) #当前python版本

print(sys.platform) # 返回操作新添平台名称

print(sys.getrecursionlimit()) # 获取最大递归层数
# sys.getrecursionlimit(1400) # 设置最大递归层数

print(sys.getdefaultencoding()) # 获取解释器默认编码

- 时间模块
时间的显示
时间的转换
时间的运算

  • 学前知识梳理
    时间戳
    从1970年1月1日之间的时间差
    格式化时间字符串
    2020-09-14 20:01
    元祖
    用9个部分表示一个时间点
  • time
import time

# print(time.time())# 当前时间戳
# 时间戳转换为元祖

# print(time.localtime(time.time()))

# print(time.gmtime()) #格林治时间


# 元祖转化为时间戳
# print(time.mktime(time.localtime(time.time())))

# 延迟时间

# print('--1--')
# time.sleep(2)
# print('hello')

# print(time.asctime()) 
#传入元祖，显示：Tue Oct 13 11:22:54 2020格式，如果不输入则为当前时间

# 元祖转化为字符串

# time_test001 = time.strftime("%Y-%m-%d %H:%M",time.localtime())
# print(time_test001)
# print(type(time_test001))

# https://www.cnblogs.com/chenfeichenyang/p/9841872.html


# 字符串转元祖
# time_test002 = time.strptime('2020/10/19 15:20', "%Y/%m/%d %H:%M")
# print(time_test002)
  • datetime
import datetime


# print(datetime.date.today())

# 转换成元祖形式
# print(datetime.date.timetuple(datetime.date.today()))

# 查看当前时间
# print(datetime.datetime.now())

# 用时间做差
# t1 = datetime.datetime.now()

# t2 = t1 - datetime.timedelta(days=5, minutes=10)
# print(t1)
# print(t2)

random

import random
import string
'''
# print(random.randint(10,1000)) # 打印10-1000的随机数字，包括10

# print(random.randrange(1,10)) # 返回1-10直接的随机数，不包括10

# print(random.randrange(0,1000,2)) # 随机生成0-10000的偶数

# print(random.random()) # 返回一个0-1直接的一个浮点数

# print(random.choice('abcdefg'))# 返回集合中的一个字符串
# print(random.sample('population', 3)) #返回多个字符串
# 洗牌
# list_test = [1,5,8,7]
# random.shuffle(list_test)
# print(list_test)
'''

# 随机生成5位验证码
print(''.join(random.sample(string.digits+string.ascii_lowercase, 5)))

猜你喜欢

转载自blog.csdn.net/qq_38874239/article/details/108638854
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022