Python开发【第二篇】：Python基础之函数-CSDN博客

本文链接：https://blog.csdn.net/m0_62588333/article/details/138367719

基本数据类型补充

set

可变类型：列表、字典，集合
不可变类型：字符串、数字、元组

集合
1、不同元素组成
2、无序
3、集合中的元素必须是不可变类型

set集合，是一个无序且不重复的元素集合

s = set('hello')
print(s)

#集合的添加
s.add('world')
print(s)

#清空集合
s.clear()

#删除集合的元素
s = {'x',1, 2, 3, 4}
s.pop()#随机删除
s.remove('x') #指定删除，没有这个值会报错
s.discard('sbb')#指定删除，没有这个值不会报错
print(s)

#利用集合简单去重，去重之后是无序的
li = [11,33,33]
li_s = set(li)
print(li_s)


#求集合的交集
s1 = {1,22,33}
s2 = {1,33}
print(s1.intersection(s2))
print(s1&s2)

#求集合的并集
s1 = {1,22,33}
s2 = {1,33,55}
print(s1.union(s2))
print(s1 | s2)

#求集合的差集
s1 = {1,22,33}
s2 = {1,33,55}
print(s2-s1) #两个减法输出的结果不一样
print(s1-s2)
print(s1.difference(s2))


#交叉补集
s1 = {1,22,33}
s2 = {1,33,55}
print(s1.symmetric_difference(s2))


#判断是否是子集
s1 = {1,2}
s2 = {1,2,3}
print(s1.issubset(s2)) # 判断s1是s2的子集
print(s2.issubset(s1)) # 判断s2是s1的子集

print(s2.issuperset(s1)) # s1 是s2的父集


#集合的更新
s1 = {1,2}
s2 = {1,2,3}
s1.update(s2) # 更新s1 
s1.union(s2) #只求并集，求完之后不会传递给s1
print(s1)

字符串格式化

常用的方法：

msg = 'i am a %s %s ' % ('boy', 'hh')
msg = 'i am a %s %s ' % ('boy', 1)
msg = 'i am a %s %s ' % ('boy',[ 'hh',11])
print(msg)

#打印浮点数
tpl = 'percent %.2f' % 99.33545
print(tpl)

#打印百分比 用两个%%
tpl = 'percent  %.2f %%' % 99.33545
print(tpl)


tpl = "i am %(name)s %(age)d years old" % {'name':'boy','age':18}
print(tpl)

2、Format方式

[[fill]align][sign][#][0][width][,][.precision][type]

fill 【可选】空白处填充的字符
align 【可选】对齐方式（需配合width使用）
- <，内容左对齐
- >，内容右对齐(默认)
- ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。即使：符号+填充物+数字
- ^，内容居中
sign 【可选】有无符号数字
- +，正号加正，负号加负；
- -，正号不变，负号加负；
- 空格，正号空格，负号加负；
# 【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
，【可选】为数字添加分隔符，如：1,000,000
width 【可选】格式化位所占宽度
.precision 【可选】小数位保留精度
type 【可选】格式化类型
- 传入” 字符串类型 “的参数
  - s，格式化字符串类型数据
  - 空白，未指定类型，则默认是None，同s
- 传入“ 整数类型 ”的参数
  - b，将10进制整数自动转换成2进制表示然后格式化
  - c，将10进制整数自动转换为其对应的unicode字符
  - d，十进制整数
  - o，将10进制整数自动转换成8进制表示然后格式化；
  - x，将10进制整数自动转换成16进制表示然后格式化（小写x）
  - X，将10进制整数自动转换成16进制表示然后格式化（大写X）
- 传入“ 浮点型或小数类型 ”的参数
  - e，转换为科学计数法（小写e）表示，然后格式化；
  - E，转换为科学计数法（大写E）表示，然后格式化;
  - f ，转换为浮点型（默认小数点后保留6位）表示，然后格式化；
  - F，转换为浮点型（默认小数点后保留6位）表示，然后格式化；
  - g，自动在e和f中切换
  - G，自动在E和F中切换
  - %，显示百分比（默认显示小数点后6位）
  - 常用格式化：
- ```
tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
  
tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
  
tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
  
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
  
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
  
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
  
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
  
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
  
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
  
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
  
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
 
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
 
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
 
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
 
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)
```
  函数
- 函数式编程最重要的是增强代码的重用性和可读性

定义和使用

def 函数名(参数):

...

函数体

...

返回值

函数的定义主要有如下要点：

def：表示函数的关键字
函数名：函数的名称，日后根据函数名调用函数
函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
参数：为函数体提供数据
返回值：当函数执行完毕后，可以给调用者返回数据。

def test(x):
    """
    
    :param x: 整形数据
    :return: 返回计算结果
    """
    y = 2*x+1
    return y
print(test)
print(test(2))

1、返回值

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

2、参数

函数的有三中不同的参数：

普通参数

# ######### 定义函数 ######### 

# name 叫做函数func的形式参数，简称：形参
def func(name):
    print name

# ######### 执行函数 ######### 
#  'gfsgf' 叫做函数func的实际参数，简称：实参
func('gfsgf')

默认参数

def func(name, age = 18):
    
    print "%s:%s" %(name,age)

# 指定参数
func('ff', 19)
# 使用默认参数
func('hh')

注：默认参数需要放在参数列表最后

动态参数

#参数组：**字典 *列表

def test(x, *args):
    print(x)
    print(args)
    print(args[0])
# test(1, 2, 3)
li = [1, 2, 3]
test(9,li) # 没加*当成一个整体传过去
test(9,*li) # 加了*一个一个传过去
输出结果：
9
([1, 2, 3],)
[1, 2, 3]
9
(1, 2, 3)
1



def func(**kwargs):

    print( kwargs)

# 执行方式一
func(name='ff',age=18)  # 注意这里的name 和 age 不能加''号


# 执行方式二
dic = {'name':'ff', 'age':18, 'gender':'male'}
func(**dic )

函数中注意的点：

1、传参过程中没有默认参数，则参数要一一对应不能少也不能多
def add(x, y): 
    return x + y 
print(add(2, 3))

2、同一个参数不能传两遍
func(name='ff',age=18,age=18)

3、万能写法，可以传任何参数

def test(x,*args,**kwargs):
    print(x)
    print(args,args[-1])
    print(kwargs,kwargs['y'])

# test(1,2,3,4,5,x=1, y=2, z=3)# 报错,因为x=1重了
test(1,2,3,4,5, y=2, z=3)

test(1,*[1,2,3,4,5],**{'y':2,'z':3})

局部变量与全局变量：

代码规范：全局变量全部大写，局部变量全部小写

全局变量是顶格写的，作用域全局

局部变量不是顶格写，作用域是有限范围内，一般在函数里面定义的变量才是局部变量

name='aa'

def chagee_name():
    global name #加了这一行就改变了全局变量的值，不加就是改的是函数里面的值
        
    name='bb'
    print(name)

chagee_name()

print(name)
注意：

1、如果函数的内容无global关键字，优先读取局部变量，只能读取全局变量，无法对全局变量重新赋值

2、如果函数中有global关键字，变量本质上就是全局的那个变量，可读取可赋值

#有声明局部变量
name = ['hgi',243]
def func():
    name  = 'ihi'

# 无声明局部变量
def fuc():
    name.append('ihi')

name = "刚娘"

def weihou():
    name = '陈卓'
    def weiweihou():
        global name
        name = '冷静'
    weiweihou()
    print(name)

print(name)
weihou()
print(name)

输出结果：
刚娘
陈卓
冷静

global 指的是全局变量，nonlobal指的是上一级变量


def weihou():
    name = '陈卓'
    def weiweihou():
        nonlocal name
        name = '冷静'

    weiweihou()
    print(name)

print(name)
weihou()
print(name)

输出结果：
刚娘
冷静
刚娘

递归

例子：

def calc(n):
    print(n)
    if int(n) % 2 == 0:
        return n
    return calc(int(n/2))

calc(10)

特性：

1、必须有一个明确的结束条件

2、每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3、递归效率不高，递归层次过多会导致栈溢出