python基础

最新推荐文章于 2024-05-21 16:18:28 发布

小刘胖嘟嘟-

最新推荐文章于 2024-05-21 16:18:28 发布

阅读量878

点赞数

文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_58196606/article/details/125870534

版权

python基础 01

Python基础导学 00

力扣，牛客网使用python3.0版本

Windows系统开发环境搭建 01

安装Python解释器（翻译成计算机可以理解的，并且执行代码），Pycharm（python代码编辑器）

基础语法巩固 02

变量是内存中的一块区域。对象赋值实际上是对象的引用。a=10
变量的命名: 变量名由字母，数字，下划线组成, 不能以数字开头. (a,b, c)

hello = 100, hello_world = 100, count2 =100, 1count=10(x)

Python中，变量定义时不需要指定类型的，当用变量的时候，必须要给这个变量赋值;

Python 支持基本数字类型:

整型（int），浮点型（float），bool值

运算符：

1). 算术运算符：+，-，*，**（次方）， /， %（取余）， //（取整）

2). 赋值运算符：=, +=, -=, /=, *=, %=

3）关系运算符: >, >=, <, <=, !=, ==

最终返回bool类型

4）逻辑运算符:逻辑与and，逻辑或or，逻辑非not

逻辑与，全真则真，一假则假

逻辑或，全假则假，一真则真

逻辑非，真就是假，假就是真

=和==的区别？

=表示赋值，==表示判断

数据的输入与输出

input 输入数据

Print 数据输出

1.格式化打印字符串：

%S：字符串

%d：整型数

%f:浮点数

%.2f:保留小数点后两位的浮点数

2.format格式化打印字符串

常用内置函数操作：

1). 标准类型函数(cmp, str和 type): 可以用于所有的标准类型。

2). 转换工厂函数(int, long, float, bool和 complex)

3). 功能函数(abs(取绝对值), divmod（返回商和余数）, pow（次方）和 round（保留小数点后几位）)

4). 进制转换函数(bin, hex, oct)

5). ASCII转换函数(chr, ord)

相关拓展模块:

decimal, array, math, random（随机取）

实例1：

编写一个程序，录入学生的姓名和三门科目的百分制成绩，计算该学生的总分和平均成绩。

输入姓名: 张三

输入语文成绩: 98

输入数学成绩: 99

输入英语成绩: 97

学生张三的总分为: 294, 平均成绩为: 98分。

进入python中的idle

name = input("请输入姓名: ")
m = int(input("请输入语文成绩: "))
n = int(input("请输入数学成绩: "))
p = int(input("请输入英语成绩: "))
s = m+n+p
avg = (int(m+n+p)/3)
print(f"总成绩为:{s}, 平均成绩为:{avg}")

也是一个顺序控制流程

三大流程控制 03

分支流程控制：

python 有两大特性, 一是简洁,二是可读性好。

Python代码块缩进完全能够清楚地表达一个语句属于哪个代码块。

Python中input接收字符串，如果接收整型数，需要通过int转换成整型数。

冒号和缩进是python的语法规范

age = int(input("年龄："))
print("成年" if age>18 else "未成年")

三元运算符是软件编程中的一个固定格式，使用这个算法可以使调用数据时逐级筛选。

语法：条件表达式？表达式1：表达式2。

含义: 如果条件表达式成立或者满足则执行表达式1，否则执行第二个。、

多分支语句

eilf 满足第二个条件做什么操作

score = int(input("成绩: "))
if 90<=score<=100:
    print("等级为A")
elif 80<=score<90:
    print("等级为B")
else:
    print("等级为C")

name = "admin"
passwd = "westos"
name = input("请输入用户名: ")
passwd = input("请输入密码: ")
if name == "admin" and passwd == "westos":
    print("用户admin登陆成功")
else:
    print("用户admin登录失败")

总结：分支语句

单分支语句：

if 条件：

满足条件执行的内容

双分支语句：

if 条件：

满足条件执行的内容

else：

不满足条件执行的内容

三元运算符（双分支的简化版）：

满足条件执行的内容 if 条件 else 不满足条件执行的内容

多分支语句：

If 条件1：

满足条件1执行的内容

elif 条件2：

满足条件2执行的内容

else:

满足条件3执行的内容

循环流程控制:

count = 0
while count <= 100:
    print(count)
    count += 1

用户登录成功进入系统，用户登录失败重新进入登录系统,并且统计登录次数:

try_count = 1
while True:
    print(f"用于第{try_count}次登录")
    try_count += 1
    name = input("请输入用户名: ")
    passwd = input("请输入密码: ")
    if name == "admin" and passwd == "westos":
        print("用户登录成功")
        exit()
    else:
        print("用户登录失败")

输出数字0-100之间的偶数：

for循环语句语法结构

与传统语言(e.g.C/C++,Java )中的 for 语句不同, Python 的 for语句更加简洁.

for循环原理(有概念即可, 讲生成器时详细说):

可以遍历序列成员, 可以用在列表解析和生成器表达式中, 它会自动地调用迭代器的 next()方法, 捕获 StopIteration 异常并结束循环(所有这一切都是在内部发生的).

range(start,end)start 开始，end-1结束

range（num）0开始，num-1结束

range(start,end，step)start 开始，end-1结束，step为步长

输出0-100之间所有的偶数

for num in range(0,101,2):
    print(num)

用for循环实现0-100之间所有的奇数：

for num in range(1,101,2):
    if num % 2 ==1:
        print(num)
    num += 1

For循环遍历字符串：

string = "mayifei"
for item in string:
    print("---",item)

range语法：

range(start, end, step =1)返回一个包含所有 k 的列表, start <= k < end , k每次递增 step

跳出循环语句break 语句和continue 语句

break语句用来终止循环语句，即循环条件没False条件或者序列还没被完全递归完，也会停止执行循环语句
```
count = 0
while count <= 10:
    count +=1
    print(count)
    if count == 5:
        break
```

2.continue 跳过当前循环的剩余语句，然后继续进行下一轮循环。（continue后面的命令不会执行）

count = 0
while count <= 10:
    count += 1
    print(count)
    if count == 5:
        continue
        print("hello")

案例一：九九乘法表：

如何让print不换行？

Print(“XXX”,end=” ”)

for i in range(1,10):
    for j in range(1,i+1):
        print(f"{i}*{j}={i*j}",end=" ")
    print()

案例二：防黑客暴力破解的用户登录系统：

需求: 根据输入用户名和密码，判断用户名和密码是否正确。为了防止暴力破解，登陆仅有三次机会，如果超过三次机会，报错提示。

数据库信息:

name='admin' passwd='westos'

try_count = 1
while True:
    print(f"用于第{try_count}次登录")
    try_count += 1
    if try_count > 4:
        print("用户已锁定")
        exit()
    name = input("请输入用户名: ")
    passwd = input("请输入密码: ")
    if name == "admin" and passwd == "westos":
        print("用户登录成功")
        exit()
    else:
        print("用户登录失败")

While循环和else结合的补充：

try_count = 0
while try_count < 3:
    try_count += 1
    print(f"用户第{try_count}次尝试登录")
else:
    print("已达最高尝试次数")

While条件表达式：

满足条件执行的内容

Else条件表达式：

不满足条件执行的内容

循环语句语法汇总：

实现循环的两种方式：while for

1.While循环：

（1）while循环：

满足条件执行的内容

（2）while循环：

满足条件执行的内容

Else：

不满足条件的内容

死循环：

While Ture：

一直可以循环的内容

for循环：

for和range的结合：

for num in range（n）：

循环的内容

for和字符串的结合：

for item in ”westos”:

for 和else的结合：

for num in range（n）：

循环的内容

Else：

循环结束后的内容

跳出循环：

Break：跳出循环

Continue：结束本次循环

Exit：退出整个程序

循环嵌套

九九乘法表

Python内置的数据类型：

Str：字符串

S1 = ’hello’

S2 = “hello”

S3 = “’ hello“’

Anrry：数组

存储同种类型的数据结构

[1.2.3] [1.1,2.2,3.3]

List：列表

可以存储不同类型的数据结构

[1,1.1,”hello”]

Tuple：元组

和列表唯一区别是增删改（如果元组里只有一个元素，一定要加逗号）

Set：集合

不重复且无序的

Dict：字典

哈希 key和value ，键值对，通过key可以快速找到value值

User = {“name”:”westos”,”age”:10}

Print(user,type(user))

python基础 02

字符串 04

字符串或串(String)是由数字、字母、下划线组成的一串字符。Python 里面最常见的类型。可以简单地通过在引号间(单引号,双引号和三引号)包含字符的方式创建它。

第一种方式：

str1 = 'our company is westos'

第二种方式：

str2 = "our company is westos"

第三种方式：

转义符号

一个反斜线加一个单一字符可以表示一个特殊字符，通常是不可打印的字符

\n 换行符用于输出

\t 水平制表符（tab键）用于输出

\\ 反斜杠字符用于表示一个反斜杠字符

\’ 单引号用于表示一个单引号字符

\” 双引号用于表示一个双引号字符

字符串的基本特性

连接操作符与重复操作符

‘hello’+’westos’

name = 'westos'
print('hello'+ name)

‘+‘*50

2.成员操作符

s = 'westos'
print('westos' in s) 
print('westos' not in s)

3.正向索引和反向索引

1. 索引(s[i] )：获取特定偏移的元素

2. 索引的分类: 正向索引, 反向索引

s = 'westos'
print(s[0])
print(s[-2])

回顾：

Range(3) {0,1,2}

Range(1,4) {1,2,3}

Range(1,6,2) {1,3,5}

切片：

1. 切片S[i:j]提取对应的部分作为一个序列：

2. 如果没有给出切片的边界，切片的下边界默认为0，上边界为字符串的长度;

扩展的切片S[i:j:k],其中i,j含义同上，k为递增步长；

3. s[:]获取从偏移量为0到末尾之间的元素，是实现有效拷贝的一种方法;

4. s[::-1]是实现字符串反转的一种方法;

S[start:end:step]

S[:end]

S[start:]

S[:n]拿出前n个元素

S[n:]除了前n个元素之外的所有元素

S[:]从头到尾所有元素

S[::-1]倒叙

需求：已知：“172”“25”“254”“100”，输出100-254-25

li = ["172","25","254","100"]
print("-".join(li[3:0:-1]))

可迭代对象/for循环

s = 'westos'
count = 0
for item in s:
    count += 1
    print(f"第{count}个字符:{item}")

names = ["粉丝","粉条","粉带"]
for name in names:
    print(f"它的名字是:{name}")

练习：用户输入一个字符串，判断字符串是否为回文字符串

例如：aba abba

Abc不是回文字符串

s1 = input("请输入字符串:")
s2 = s1[::-1]
if s1 == s2:
    print(f"{s1}为回文字符串")
else:
    print(f"{s1}不是回文字符串")

Pycahrm 新建文件：alt+insert

Pycharm 格式化代码符合pep8 代码风格（ctrl+alt+L）

Pycharm Ctrl+d：复制一行

字符串内建方法

字符串的判断与转换：

title: 标题需要每一个首字母大写，e.g. Hello Python

space: 空格指的是广义的空格， e.g: \n, \t,

字符串的类型判断

isdigit: 全数字

isupper: 全大写

islower: 全小写

isarpha:

isalum: 字母或数字

s = 'Hello WestoS'
print(s.isalnum())
print(s.isdigit())
print(s.isupper())

字符串的类型转换

upper：转成大写

lower：转成小写

title：成标题

swapcase：大写转成小写，小写转成大写

print('hello'.upper())
print('HellO'.lower())
print('HellO WEstos'.title())
print('HellO WEstos'.swapcase())

字符串的开头和结尾匹配：

开头：startswith

url = 'http://baidu.com'
if url.startswith('http'):
    print(f"可以访问{url}")

结尾：endswith

filename = 'hello.png'
if filename.endswith("png"):
    print(f"{filename}是一个图片文件")

字符串的数据清洗

lstrip: 删除字符串左边的空格（广义的空格：\n,\t,” ”）

rstrip: 删除字符串右边的空格（广义的空格：\n,\t,” ”）

strip: 删除字符串左边和右边的空格（广义的空格：\n,\t,” ”）

replace：替换函数删除中间的空格，将空格替换为空 replace(“”, )

字符串的位置调整

center() 字符串居中且为指定长度

ljust() 字符串靠左且为指定长度

rjust() 字符串靠右且为指定长度

print("学生管理系统".ljust(10,"*"))
print("学生管理系统".rjust(10,"*"))
print("学生管理系统".center(10,"*"))

字符串的搜索,统计

find(str,beg,end) 检测str是否包含在string中，返回索引

index(str,beg,end) 检测str是否包含在string中，返回索引，否则抛出异常

count(str,beg,end) 检测str在string中一共出现的次数

作业：

编写一个函数来验证输入的字符串是否是有效的 IPv4 ?

1). IPv4 地址由十进制数和点来表示，每个地址包含4个十进制数，其范围为 0 - 255，用(".")分割。

比如，172.16.253.1；

2). IPv4 地址内的数不会以 0 开头。比如，地址 172.16.254.01 是不合法的。

其他内置方法

cmp( ) 根据字符串的 ASCII 码值进行比较(py3取消)

len( ) 返回字符串的字符数

max( ) and min( ) 返回最大或者最小的字符,(按照 ASCII 码值排列)

enumerate( ) 枚举对象同时列出数据和数据下标

zip( ) 将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

随机生成100个验证码，由6个字符组成：

设计一个程序，用来实现帮助小学生进行算术运算练习，它具有以下功能：提供基本算术运算(加减乘)的题目，每道题中的操作数是随机产生的，练习者根据显示的题目输入自己的答案，程序自动判断输入的答案是否正确并显示出相应的信息。最后显示正确率。

import random
count = 10
right_count = 0
for i in range(count):
    num1 = random.randint(1,10)
    num2 = random.randint(1,10)
    symbol = random.choice(["+","-","*"])
    result = eval(f"{num1}{symbol}{num2}")
    print(f"{num1} {symbol} {num2} = ? ")
    user_answer = int(input("answer:"))
    if user_answer == result:
        print("right")
        right_count += 1
    else:
        print("error")
print("right percent: %.2f%" %(right_count/count*100))

python基础 03

列表&元组 05

序列：

成员有序排列的,且可以通过下标偏移量访问到它的一个或者几个成员,这类类型统称为序列。

序列数据类型包括:字符串,列表,和元组类型。

特点: 都支持下面的特性 1.索引与切片操作符 2.成员关系操作符(in , not in) 3.连接操作符(+) & 重复操作符(*)

数组:

存储同一种数据类型的集和。scores=[12,95.5] 列表(打了激素的数组): 可以存储任意数据类型的集和。

创建一个空列表

li = []
print(li, type(li))
li1 = [1]
print(li1, type(li1))

list = []

bool类型中：

TRUE：1

FALSE：0

创建一个包含元素的列表，元素可以是任意类型，包括数值类型，列表，字符串等均可, 也可以嵌套列表。

list = ["fentiao", 4, 'gender']

list = [['粉条', 100], ["粉丝", 90], ["粉带", 98]]

列表的添加：

1）追加：列表可通过append追加一个元素到列表中;

li = [1,2,3]
li.append(4)
print(li)

2）在列表开头添加：在指定位置添加元素使用insert方法； L.insert(index, object)

li = [1,2,3]
li.insert(0,"ma")
print(li)

3）一次追加多个元素：列表可通过extend方法拉伸, 实现追加多个元素到列表中

li = [1,2,3]
li.extend([4,5,6])
print(li)

列表的修改：

索引修改:

li = [1,2,3]
li[0] = "ma"
li[-1] = "liu"
print(li)

切片修改：

li = [1,2,3]
li[:2] = ["ma","liu"]
print(li)

列表的查看：通过索引和切片查看元素。查看索引值和切片次数。

li = [1,2,3,1,2,1]
print(li.count(1))
print(li.index(2))

列表的删除：

list.remove()删除列表中的指定元素。

li = [1,2,3]
li.remove(1)
print(li)

list.pop()根据元素的索引值进行删除指定元素。

li = [1,2,3]
print(li.pop(-1))
print(li)

list.clear: 清空列表里面的所有元素。

li = [1,2,3]
li.clear()
print(li)

将pop方法的结果存储到delete_num中

li = [1,2,3]
delete_num = li.pop(-1)
print(li)
print(f"删掉的元素是:", delete_num)

其他操作：

1）反转

li = [12,34,23,56]
li.reverse()
print(li)

2）sort从小到大排

li = [12,34,56,23]
li.sort()
print(li)

sort从大到小排：

li = [12,23,34,45,24]
li.sort(reverse = True)
print(li)

copy复制：

li = [12,223,34,45]
li1 = li.copy()
print(id(li),id(li1))
print(li,li1)

元组（tuple不能修改元素）的创建，删除及特性

1). 定义空元组 tuple = ()

t = ()
print(t,type(t))

2). 定义单个值的元组（一定要加逗号） tuple = (fentiao,)

3). 一般的元组 tuple = (fentiao, 8, male)

特性: 连接&重复操作符、成员操作符、索引&切片

注意: 元组是不可变数据类型，不能对元组的值任意更改；

元组的方法

t.count(value)-->int 返回value在元组中出现的次数；

t.index(value) 返回value在元组中的偏移量(即索引值)

命名元组

Tuple还有一个兄弟，叫namedtuple。虽然都是tuple，但是功能更为强大。

collections.namedtuple(typename, field_names)

typename：类名称

field_names: 元组中元素的名称

定义命名元组类与应用

命名元组是一个类，有两种方式来定义命名元组：

from collections import namedtuple
user = namedtuple("user",("name","age","city"))
user1 = user("root","18","xian")
print(user1)
print(user1.name)
print(user1.age)
print(user1.city)

实例化命名元组，获得类的一个实例：

访问命名元组: 通过逗号运算符和属性名来访问元组字段的值 user.name; user.age, user.id

类属性 _fields：包含这个类所有字段名的元组

类方法 _make(iterable)：接受一个可迭代对象来生产这个类的实例

实例方法_replace()：用于修改实例的属性

is和==的区别

问题: is和==两种运算符在应用上的本质区别是什么?

1). Python中对象的三个基本要素，分别是：id(身份标识)、type(数据类型)和value(值)。

2). is和==都是对对象进行比较判断作用的，但对对象比较判断的内容并不相同。

3). ==用来比较判断两个对象的value(值)是否相等；(type和value) is也被叫做同一性运算符，会判断id是否相同;(id, type 和value)

print(1 == "1")
li = [1,2,3]
li1 = li.copy()
print(li == li1)
print(li is li1)

在python语言中：

==：类型和值是否相等

is：类型和值是否相等，内存地址是否相等

深拷贝和浅拷贝

1.值得引用

nums1 = [1,2,3]
nums2 = nums1
nums1.append(4)
print(nums2)

nums1和nums2指向同一存储空间

问题: 深拷贝和浅拷贝的区别?/python中如何拷贝一个对象?

赋值：创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。(=)

浅拷贝：对另外一个变量的内存地址的拷贝，这两个变量指向同一个内存地址的变量值。(li.copy(), copy.copy())

公用一个值；

这两个变量的内存地址一样；

对其中一个变量的值改变，另外一个变量的值也会改变；

n1 = [1,2,3]
n2 = n1.copy()
print(id(n1),id(n2))
n1.append(4)
print(n2)

深拷贝：一个变量对另外一个变量的值拷贝。(copy.deepcopy())

两个变量的内存地址不同；

两个变量各有自己的值，且互不影响；

对其任意一个变量的值的改变不会影响另外一个；

可变数据类型：list

不可变数据类型：str，数值型，tuple，namedtuple

n1 = [1,2,[3,4]]
n2 = n1.copy()
n1[-1].append(5)
print(n2)

如果有列表嵌套的时候，或者列表中包含可变数据类型时，一定要选择深拷贝。

拓展：批量注释：选中注释的内容，ctrl+#

集合&字典 06

集合

集合（set）是一个无序的不重复元素序列。

1,2,3,4,1,2,3 = 1,2,3,4 集合的创建:

1). 使用大括号 { } 或者 set() 函数创建集合;

2). 注意：创建一个空集合必须用 set() 而不是 { }

{ } 是用来创建一个空字典。

s = {}
print(s,type(s))

s = set()
print(s,type(s))

集合的创建：不可变的数据类型

s = {1,2,3,4,1,2,3}
print(s,type(s))

集合的特性：

不支持+，*，index，slice（因为集合无序不重复）

支持in和not in

集合的常用操作：

1.增加

add：添加单个元素

s = {1,2,3}
s.add(4)
print(s)

update:添加多个元素

s = {1,2,3}
s.update({4,5,6})
print(s)

2.删除

remove：元素如果存在，删除；不存在报错

discard：元素如果存在，删除；不存在不进行操作

pop：随机删除元素，集合为空报错

3.查看

差集：s1-s2

交集：s1&s2

对称差分：s1^s2:并集-交集

并集：s1 | s2

s1.subset(s2) ： s2是不是s1的子集？

s1.disjoint(s2)：s1和s2没有交集嘛？

4.拓展

frozenset 是 set 的不可变版本，因此 set 集合中所有能改变集合本身的方法（如 add、remove、discard、xxx_update 等），frozenset 都不支持；set 集合中不改变集合本身的方法，fronzenset 都支持。

frozenset 的这些方法和 set 集合同名方法的功能完全相同。

frozenset 的作用主要有两点：

当集合元素不需要改变时，使用 frozenset 代替 set 更安全。

当某些 API 需要不可变对象时，必须用 frozenset 代替set。比如 dict 的 key 必须是不可变对象，因此只能用 frozenset；再比如 set 本身的集合元素必须是不可变的，因此 set 不能包含 set，set 只能包含 frozenset。

练习题：

import random
s = set()
for i in range(1,1001):
    s.add(random.randint(0,1000))
s = sorted(s,reverse = True)
print(s)

字典

字典是另一种可变容器模型，且可存储任意类型对象。键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

d = {key1 : value1, key2 : value2 }

d = {'Z' : '字', 'D' : '典' }

字典的创建：

d = {"name":"westos","age":"18","city":"xian"}
print(d,type(d))

字典的特性：

不支持+，*，index，slice（因为集合无序不重复）

支持in和not in

字典的常用方法：

1.查看

d.keys()：查看所有的key值

d.values()：查看所有的value值

d.items()：查看字典的key，value值

d["key"]：查看key所对应的value值

d["不存在"]：报错

d.get("不存在")：不存在返回none

d.get("不存在"，"默认值")：返回默认值

2.增加和修改

d["city"] = "xian"

3.删除

d.pop["key"]

del d["key"]

4.遍历字典

默认情况下，字典只会遍历key值。

如何遍历key值和value值？

练习：

defaultdict 是 dict 的子类。但它与 dict 最大的区别在于，如果程序试图根据不存在的 key 访问 value，会引发 KeyError 异常；而 defaultdict 提供default_factory 属性，该为不存在的 key 来自动生成生成默认的 value。

需求：我们想要一个能将键（key）映射到多个值的字（即所谓的一键多值字典）

解决方案： 1). 字典是一种关联容器，每个键都映射到一个单独的值上。如果想让键映射到多个值，需要将这些多个值保存到容器（列表或者集合）中。 2). 利用collections模块中的defaultdict类自动初始化第一个值，这样只需关注添加元素.

数据类型的汇总

可变数据类型:list，set，dict

可以增删改。可变数据类型，允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。

不可变数据类型:数值类型，tuple，str

不可以增删改。python中的不可变数据类型，不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象，内部会有一个引用计数来记录有多少个变量引用这个对象。

有序序列拥有的特性: 索引、切片、连接操作符、重复操作符以及成员操作符等特性。

函数：

常用的内置函数：

max，min，sum，divmod

函数必须有输入输出

函数的输入叫参数

形参：不是真实的值（定义函数时的值）

实参：是真实的值（调用函数时的值）

函数的输出叫返回值

max_num = max(1,2,3)
print(max_num)

如何创建函数？创建函数，函数内容不会执行

def get_max(num1,num2):
    result = num1 if num1 > num2 else num2
    return result

如何调用函数？

def get_max(num1,num2):
    result = num1 if num1 > num2 else num2
    return result
max_num = get_max(23,45)
print(max_num)

为什么需要函数？

如果在开发程序时,需要某块代码多次,但是为了提高编写的效率以及代码的重用,所以把具有独立功能的代码块组织为一个小模块,这就是函数.

从实现函数的角度来看，其至少需要想清楚以下 3 点：

函数需要几个关键的需要动态变化的数据，这些数据应该被定义成函数的参数。

函数需要传出几个重要的数据（就是调用该函数的人希望得到的数据），这些数据应该被定义成返回值。

函数的内部实现过程。

定义函数，也就是创建一个函数，可以理解为创建一个具有某些用途的工具。定义函数需要用 def 关键字实现，范例如下：

空函数：

定义一个什么事也不做的空函数,可以用 pass 语句；pass 可以用来作为占位符,还没想好怎么写函数的代码,就可以先放一个 pass ,让代码能运行起来。

函数的调用

调用函数也就是执行函数。如果把创建的函数理解为一个具有某种用途的工具，那么调用函数就相当于使用该工具。函数调用的基本语法格式：函数名([形参值])

所谓“返回值”,就是程序中函数完成一件事情后,最后给调用者的结果. 没有返回值，默认返回None

从理论上说，不用函数，也能够编程，我们在前面已经写了程序，就没有写函数，当然，用python的内建函数姑且不算了。现在之所以使用函数，主要是：

1. 降低编程的难度(分而治之的思想)

2. 代码重用。避免了重复劳动，提供了工作效率。

变量作用域

可变数据类型：列表，字典，集合

不可变数据类型：str，数值型，tuple

1.全局变量：全局生效的变量函数外的变量

def login():
    name = "admin"
    print(name)
login()

def login():
    print(name)
name = "admin"
login()

2.局部变量：局部生效的变量函数内的变量

def logout():
    age = 19
    print(age)
logout()

3.函数内部修改局部变量

city = "xian"
def hello():
    city = "beijing"
    print(city)
hello()

小刘胖嘟嘟-

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
python基础

可变数据类型，允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。从理论上说，不用函数，也能够编程，我们在前面已经写了程序，就没有写函数，当然，用python的内建函数姑且不算了。浅拷贝对另外一个变量的内存地址的拷贝，这两个变量指向同一个内存地址的变量值。...
复制链接

扫一扫