python基础（切片，函数入门）

最新推荐文章于 2024-10-08 13:57:29 发布
最新推荐文章于 2024-10-08 13:57:29 发布
阅读量2.1k 收藏 2
点赞数 1
分类专栏： python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38874239/article/details/108638854
版权

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)))
python切片
weixin_33365807的博客
12-13 322
python的切片操作适用于有索引的数据结构 切片方式 python的切片一般包含三个参数，start_index、end_index、step step的方向应与start_index—>end_index的方向一致 切片举例 1.切取单个元素 #当索引只有一个数时，表示切取某一个元素。 >>>a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>>a[0] >>>0 >>>a[-4] >>&gt
Python中的split()函数的用法
weixin_30312557的博客
07-24 6254
函数：split() Python中有split()和os.path.split()两个函数，具体作用如下：split()：拆分字符串。通过指定分隔符对字符串进行切片，并返回分割后的字符串列表（list）os.path.split()：按照路径将文件名和路径分割开 一、函数说明 1、split()函数语法：str.split(str="",num=string.count(str))[...
彻底搞懂【Python】切片操作
最新发布
GR001009的博客
10-08 1403
在利用Python解决各种实际问题的过程中，经常会遇到从某个对象中抽取部分值的情况，正是专门用于完成这一操作的有力武器。理论上而言，只要条件表达式得当，可以通过单次或多次切片操作实现任意切取目标值。切片操作的基本语法比较简单，但如果不彻底搞清楚内在逻辑，也极容易产生错误，而且这种错误有时隐蔽得比较深，难以察觉。本文通过详细例子总结归纳了切片操作的各种情况。若有错误和不足之处请大牛指正！
python字符串切片操作示例_Python切片操作实例分析
weixin_39892481的博客
11-26 998
本文实例讲述了Python切片操作。分享给大家供大家参考，具体如下：在很多编程语言中，针对字符串提供了截取函数，其实目的就是对字符串切片。Python没有针对字符串的截取函数，只需要切片操作就可以完成。切片操作符是序列名后跟一个方括号，方括号中有3个可选的数字，并用冒号分割,数是可选的，而冒号是必须的。切片操作符中的第一个数表示切片开始的位置，第二个数表示切片到哪里结束，第三个数表示切片步长。如果...
Python 中的 slice() 函数：切片的利器
GitHub_miao的博客
02-26 1870
slice()函数是 Python 中的一个内置函数，用于创建切片对象。切片对象可以用来指定对序列进行切片操作的起始、终止和步长值。slice()start是切片的起始位置（默认为 0）。stop是切片的终止位置（默认为序列的长度）。step是切片的步长（默认为 1）。切片对象可以用于实现自定义的切片逻辑，例如获取序列的奇数索引元素。# 获取序列的奇数索引元素在这个示例中，使用切片对象odd_slice获取列表中奇数索引位置的元素。除了常见的切片操作外，slice()
Python中的切片(详细篇)学起来喔
热门推荐
Zombie_QP的博客
05-31 11万+
Python中切片的切法,是什么,怎么切.
python基础入门（超详细）.pdf
06-12
以下是一些关于Python基础入门的知识点： 1. **Input和Output**：`input()` 函数用于从用户那里获取输入，例如在例子中用来获取密码。`print()` 函数则用于在控制台输出信息。在示例中，它被用来显示用户输入的密码...
Python基础入门学习
03-11
"Python基础入门学习"课程涵盖了96个课时的详细讲解，旨在帮助初学者全面掌握Python的基础知识。 课程内容从Python的基本语法开始，包括变量和字符串的使用。在"003小插曲之变量和字符串.mp4"中，你会学习到如何...
python基础入门知识_基础入门_python_
10-02
"Python基础入门知识"这个主题覆盖了Python编程的基础内容，适合对编程感兴趣或者想要转行进入IT行业的新人。 1. **Python安装**：在开始Python编程之前，首先需要在个人电脑上安装Python解释器。Python官网提供各...
简易Python基础教程 Python新手入门教程 Python基础入门教程 共19页.pdf
06-04
这篇"简易Python基础教程"旨在为新手提供一个全面的入门指南，覆盖了从基本概念到核心概念的多个方面。 1. **Python的应用场合**： Python广泛应用于Web开发、数据分析、人工智能、自动化脚本、网络编程等多个领域...
超完整 Python基础入门知识教程 Python从入门到进阶知识大全 Python开发基础知识能力集全部课件 1885页
03-14
### Python基础入门知识教程知识点概览 #### 一、Python的发展历史及背景 - **起源**: Python由Guido van Rossum在1989年的圣诞节期间，在荷兰Amstelveen开始设计。Guido的设计目标是将C语言的高效性和易用性结合...
python切片迭代_Python函数、切片、迭代学习小结
weixin_39583029的博客
12-22 99
一、函数1.在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。2.如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。3.Python函数可以返回多个返回值，但是究其根本它其实只是反回了一个tuple，而tuple中包含多值。4.Python的函数里可以定义默认参数，比...
python 切片
KyrieHe的博客
10-25 607
str = [1, 2, 3, 4, 5, 6]str[0:3] #截取第一位到第三位的字符 str[:] #截取字符串的全部字符 str[6:] #截取第七个字符到结尾 str[:-3] #截取从头开始到倒数第三个字符之前 str[2] #截取第三个字符 str[-1] #截取倒数第一个字符 str[::-1] #创造一个与原字符串顺序相反的字符串 str[-3:-1] #截取倒数第三位与倒数第一
Python入门学习（二）——函数、切片
weixin_30687811的博客
04-12 208
1.函数 要调用一个函数，需要知道函数的名称和参数。 可以查看Python标准库：https://docs.python.org/2/library/index.html，也可以在交互式命令行通过 help(abs) 查看函数的帮助信息。 s = area_of_circle(x) #圆的面积 s = abs(-1.5) #绝对值函数 cmp(x, y) ...
python 切片函数,python切片详解
weixin_31748999的博客
03-25 2733
先从原理上分析切片运算：list的切片，内部是调用__getitem__，__setitem__,__delitem__和slice函数。而slice函数又是和range()函数相关的。给切片传递的键是一个特殊的slice对象。该对象拥有可描述所请求切片方位的属性，例如：a = [ 1, 2, 3, 4, 5, 6 ]x = a [ 1 : 5 ] # x = a.__getitem__( sl...
python切片操作
chase
09-28 1万+
python切片操作教程
python语法基础---切片及函数
m0_55785131的博客
11-09 3039
切片： 切片只有在python独有的功能，能将对象中的内容切出来。 语法：object[起始下标：结束下标：步数] 结束下标：取不到改下标的值 步数（step):正数表示从左向右进形切片，负数表示从右到左进行切片，如果不写默认 step=1 一.切objdaect的单个值 ： >>> a=[1,2,3,4,5,6,7] >>> a[2] 3 >>> 语法：object[下标] 注意：当改下标不存在时会报错 二.切取多个数值...
python中的切片
haoshan4783的博客
12-27 409
line=“abcd” line[:-1]的结果为: abc line[::-1]的结果为:dcba #[::-1]中省略起止位置，步进为-1 在python中，当步进为正，从左往右取；步进为负，从右往左取 line[::-1]实现字符串翻转 ...
Python入门--切片和函数
qq_45685587的博客
06-05 720
一、耦合 1、耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。 2、在软件工程中，对象之间的耦合度就是对象之间的依赖性。对象之间的耦合越高，维护成本越高，因此对象的设计应使类和构件之间的耦合最小。 3、分类：有软硬件之间的耦合，还有软件各模块之间的耦合。耦合性是程序结构中各个模块之间相互关联的度量。它取决于各个模块之间的接口的复杂程度、调用模块的方式以及哪些信息通过接口。 二、解耦 1、解耦，字面意思就是解除耦合关系。 2、在软件工程中，降低耦合度即可以理解为解
Python基础巩固：函数与递归解析
"这篇资料主要讲述了重新学习Python入门知识的重要性，强调了基础知识对于后续学习的支撑作用，尤其在遇到技术瓶颈时，回顾基础能够帮助提升信心和弥补不足。作者分享了从Jupyter Notebook中学习的经验，并感谢B站UP...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值