Python编程基础

Posted 雨宙

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python编程基础相关的知识,希望对你有一定的参考价值。

Python编程基础(二)

打卡第二天啦!!!

函数

初识函数

  1. 什么是函数:函数是一系列Python语句的组合,可以在程序中运行一次或多次,一般是完成具体的独立的功能
  2. 为什么要使用函数:代码复用最大化
  3. 函数定义:
    def 函数名(参数列表):
      函数体
  4. 函数的调用:本质上是去执行函数定义里面的代码块,在调用函数之前必须先定义
# 函数的定义
'''
打印个人信息
'''
def person_info(name,age):
    # 函数代码块
    print('姓名:'.format(name))
    print('年龄:'.format(age))
    pass
# 函数的调用
person_info('潘小雷',20)
person_info('鲸鱼',20)
# 姓名:潘小雷
# 年龄:20
# 姓名:鲸鱼
# 年龄:20

函数参数

  1. 参数分类:必选参数、默认参数[缺省参数]、可选参数、关键字参数
  2. 参数:函数为了实现某项特定的功能,进而为了得到实现功能所需要的数据
  3. 必选参数:
def sum(a,b): #a和b为形式参数,知识意义上的参数,在定义的时候不占内存地址
    sum=a+b
    print(sum)
    pass
# 函数调用,必选参数在调用的时候必选参数是必须要赋值的
sum(1,2) #实际参数,是实际占用内存地址的
  1. 默认参数:
    注:默认参数始终存在于参数列表的尾部
# 默认参数始终存在于参数列表的尾部
def sum1(a=20,b=30):
    print('sum='.format(a+b))
    pass
# 默认参数调用 在调用的时候如果未赋值,就会用定义函数时给定的默认值
sum1()
sum1(10)
sum1(10,10)
# sum=50
# sum=40
# sum=20
  1. 可选参数:
    (1)接受的数据是元组类型
# 可选参数,当参数的个数不确定时使用
def getComputer(*args):
    print(args)
    pass
getComputer(1) # (1,)
getComputer(1,2,3) #(1, 2, 3)
def sum2(*args):
    sum=0
    for item in args:
        sum+=item
        pass
    print(sum)
    pass
sum2(1,2,3,4,5) #15
  1. 关键字参数:
    (1)接受的数据是字典类型
    注:可选参数必须放到关键字参数之前
# 关键字参数
# ** 来定义
# 函数体内 参数关键字是一个字典类型 key是一个字符串
def keyFunc(**kwargs):
    print(kwargs)
    print(*kwargs)
    pass
# 函数调用
dictA="name":'潘小雷',"age":'20'
keyFunc(**dictA)
# 'name': '潘小雷', 'age': '20'
# name age
keyFunc(name='潘小雷',age=20)
# 'name': '潘小雷', 'age': '20'
# name age

# 可选参数必须放到关键字参数之前
def complexFunc(*args,**kwargs):
    print(args)
    print(kwargs)
    pass
complexFunc(1,2,3)
# (1, 2, 3)
# 
complexFunc(**dictA)
# ()
# 'name': '潘小雷', 'age': '20'

函数返回值

  1. 概念:函数执行完会返回一个对象,如果在函数内部有return,就可以返回实际的值,否则返回None
  2. 类型:可以返回任意类型,返回值类型应该取决于return后面的类型
  3. 用途:给调用方返回数据
  4. 在一个函数体内可以出现多个return,但是肯定只能返回一个return
  5. 如果在一个函数体内,执行了return,意味着函数就退出了,return后面的代码语句将不会执行
# 返回一个值
def sum(a,b):
    sum=a+b
    return sum
res=sum(1,2)
print(res) #3

# 返回一个列表
def calComputer(num):
    li=[]
    result=0
    i=1
    while i<=num:
        result+=i
        i+=1
        pass
    li.append(result)
    return li
value=calComputer(10)
print(value) #[55]

函数嵌套调用

def func1():
    print('-------func1-----------')
    pass
def func2():
    print('-------func2-----------')
    func1()
    pass
func2()
# -------func2-----------
# -------func1-----------

函数的基本类型

  1. 根据函数的返回值和函数的参数可以将函数进行分类:
    (1)有参数无返回值的
    (2)有参数有返回值的
    (3)无参数有返回值的
    (4)无参数无返回值的

全局变量和局部变量

局部变量

  1. 在函数内部定义的变量,作用域仅仅局限在函数的内部
  2. 不同的函数可以定义相同的局部变量,之间不会产生影响
  3. 作用:为了临时地保存数据,需要在函数中定义来进行存储

全局变量

  1. 当全局变量和局部变量出现重复时,程序会优先执行使用函数内部定义的变量
  2. 使用global关键字在函数内部修改全局变量

函数参数引用传值

  1. 在函数调用时,实参传递的是对象的引用
  2. 参数传递是通过对象引用来完成的,注意可变类型和不可变类型的区别
# 不可变类型
a=1
def func(x):
    print('x的地址'.format(id(x)))
    x=2
    print('修改后x的地址'.format(id(x)))
    print(x)
    pass
print('a的地址'.format(id(a)))
func(a)
print(a)
# a的地址140735484798752
# x的地址140735484798752
# 修改后x的地址140735484798784
# 2
# 1

# 可变类型
li=[]
def test(params):
    params.append([1,2,3])
    print('内部变量对象'.format(params))
    pass
test(li)
print('外部变量对象'.format(li))
# 内部变量对象[[1, 2, 3]]
# 外部变量对象[[1, 2, 3]]

匿名函数

  1. 语法:lambda 参数1、参数2…:表达式
  2. 特点:使用lambda关键字创建函数,没有名字,匿名函数冒号后面的表达式有且只有一个,注意:是表达式而不是语句
  3. 匿名函数自带return,而这个return结果就是表达式计算后的结果
  4. 通过变量调用匿名函数
  5. 缺点:lambda只能是单个表达式,不是一个代码块,仅仅能封装有限逻辑,复杂逻辑实现不了
test=lambda x,y:x+y
test(1,2) #3
#可以替换传统双分支
age=17
print('可以参军'if age>18 else '继续上学')  #继续上学
testA=lambda x,y:x if x>y else y
testA(1,4) #4
res=(lambda x,y:x if x>y else y)(16,12)
print(res) #16

递归函数

  1. 如果一个函数在内部不调用其他的函数,而是自己本身的话,这个函数就是递归函数
  2. 满足的条件:自己调自己、必须有递归出口
  3. 缺点:容易导致栈溢出
  4. 优点:逻辑简单、定义简单
def func(n):
    if n==1:
        return 1
    return n*func(n-1)
func(5) #120
import os
def findFile(file_Path):
    listRs=os.listdir(file_Path)
    for fileItem in listRs:
        full_path=os.path.join(file_Path,fileItem)
        if os.path.isdir(full_path):
            findFile(full_path)
            pass
        else:
            print(fileItem)
            pass
        pass
    else:
        return
    pass
findFile('C:\\\\Users\\Rainy_Universe\\Desktop\\大二春季学期')

Python内置函数

内置函数简介

  1. Python语言自带函数

数学运算函数

# 绝对值
abs(-10) #10
# 近似值
round(3.66) #4
round(3.66,1) #3.7
# 求指数
pow(2,4) #16
# 求最大值最小值
max(1,2,3,4,5) #5
max([1,2,3,4,5]) #5
min(1,2,3,4,5) #1
# 求和
sum((1,2,3,4),5) #15
sum(range(6)) #15
# 动态执行表达式
a,b,c=1,2,3
eval('a+b+c') #6
def hello():
    print('hello')
    pass
eval('hello()') #hello

类型转换函数

# 数字转字符
chr(65) #'A'
# 转为二进制
bin(10) #'0b1010'
# 转为十六进制
hex(32) #'0x20'
# 元组转为列表
tup=(1,2,3,4)
print(list(tup)) #[1, 2, 3, 4]
# 创建字典
dic=dict(name='潘小雷',age='20')
print(dic)
#'name': '潘小雷', 'age': '20'
# 转换为字节数组
bytes('潘小雷',encoding='utf-8')
# b'\\xe6\\xbd\\x98\\xe5\\xb0\\x8f\\xe9\\x9b\\xb7'

序列操作

  1. all函致用于判断给定的可迭代参数iterable中的所有元素是否都为TRUE,如果是返回True,否则返回False,元素除了是0、空、FALSE外都算 TRUE(可迭代参数理解为元组或列表)
li=[1,2,3]
all(li) #True
list=[1,2,3,0]
all(list) #False
all([]) #True
all(()) #True
all([1,2,False]) #False
  1. any()函数用于判断给定的可迭代参数iterable是否全部为False,则返回False,如果有一个为True,则返回True。
  2. sorted()函数对所有可迭代的对象进行排序操作
    (1)sort是应用在list上的方法,sorted可以对所有可迭代的对象进行排序操作
    (2)list的sort方法返回的是对已经存在的列表进行操作,二内建函数sorted方法返回的是一个新的list,而不是在原来的基础上进行的操作
li=[2,45,1,67]
li.sort() # list的排序方法,直接修改原始对象
print(li) #[1, 2, 45, 67] 

list=[1,45,87,24]
varList=sorted(list)
print(list) #[1, 45, 87, 24]
print(varList) #[1, 24, 45, 87]
varListA=sorted(list,reverse=True)
print(varListA) #[87, 45, 24, 1]

tupArray=(1,45,87,24)
varTuple=sorted(tupArray)
print(varTuple) #[1, 24, 45, 87]
  1. reverse()函数用于反向列表中的元素
  2. range()函数可创建一个整数列表,一般用于for循环中
  3. zip()函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表,如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用*操作符,可将元组解压为列表
s1=['a','b','c']
s2=['你','我','他']
s3=['1','2','3','4']
print(zip(s1)) #<zip object at 0x000002449D301980>
print(list(zip(s1))) #[('a',), ('b',), ('c',)]
zipList=zip(s1,s2) #<zip object at 0x000001F1F8B835C8>
print(list(zipList)) #[('a', '你'), ('b', '我'), ('c', '他')]
zipListA=zip(s1,s3)
print(list(zipListA)) #[('a', '1'), ('b', '2'), ('c', '3')]
def printBookInfo():
    books=[] #存储所有图书信息
    id=input("请输入图书编号:每个项以空格分割")
    bookName=input("请输入书名:每个项以空格分割")
    bookPos=input("请输入位置:每个项以空格分割")
    idList=id.split(' ')
    nameList=bookName.split(' ')
    posList=bookPos.split(' ')

    bookInfo=zip(idList,nameList,posList)
    for bookItem in bookInfo:
        dictInfo="编号":bookItem[0],"书名":bookItem[1],"位置":bookItem[2]
        books.append(dictInfo)
        pass
    for item in books:
        print(item)
        pass

printBookInfo()
# 请输入图书编号:每个项以空格分割1 2
# 请输入书名:每个项以空格分割书1 书2
# 请输入位置:每个项以空格分割位置1 位置2
# '编号': '1', '书名': '书1', '位置': '位置1'
# '编号': '2', '书名': '书2', '位置': '位置2'
  1. enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在for循环中
listObj=['a','b','c']
for item in enumerate(listObj):
    print(item)
    pass
# (0, 'a')
# (1, 'b')
# (2, 'c')
for index,item in enumerate(listObj):
    print(index,item)
    pass
# 0 a
# 1 b
# 2 c
for index,item in enumerate(listObj,5):
    print(index,item)
    pass
# 5 a
# 6 b
# 7 c
dictObj=
dictObj['name']='潘小雷'
dictObj['age']='20'
for index,item in enumerate(dictObj):
    print(index,item)
# 0 name
# 1 age

内置函数set

  1. set集合也是Python中的一种数据类型,是一个无序且不重复的元素集合
  2. 集合操作函数
# 创建
set1=1,2
print(set1)
listA=[1,2,3]
set2=set(listA)
print(set2)
# 1, 2
# 1, 2, 3

# 添加
set1.add('Python')
print(set1)
# 1, 2, 'Python'

# 清空
set2.clear()
print(set2)
# set()

# 取差集
a=1,2,3,4,5
b=1,2,4,6,7
c=a.difference(b)
print(c)
# 3, 5

# 取交集
print(a.intersection(b))
# 1, 2, 4

# 取并集
print(a.union(b))
# 1, 2, 3, 4, 5, 6, 7

# 取出数据并删除
a.pop()
print(a)
# 2, 3, 4, 5

# 移除指定数据
a.discard(3)
print(a)
# 2, 4, 5

# 更新
a.update(b)
print(a)
# 2, 1, 4, 5, 6, 7

以上是关于Python编程基础的主要内容,如果未能解决你的问题,请参考以下文章

周报月报书是不是让你很烦,今天介绍一本零基础入门Python数据分析的书

鲸鱼电台 | 非对称加密的相关名词介绍

你有关于视频游戏编程的好书名吗? [关闭]

基于改进鲸鱼算法实现WSN节点优化覆盖matlab代码

Python编程导论 第2版

WSN布局基于改进鲸鱼算法实现WSN节点优化覆盖matlab代码