Python学习记录

Python学习记录

第一章

1.1 第一个程序

print('Hello World')

运行结果：

第二章

2.1 打印输出

print 打印，将一些信息输出显示出来
1.字符串 (String) ，即一串文本字符，用英文单引号包括
print (‘你好’)
2.数字 (Number) ，不需要用单引号
print ( 2023 )
3.混合输出：一次性地输出多个数据
print( ‘一共有’ , 30 , ‘个学生’ )
其中，小括号有多个数据， 用逗号分隔

print ('你好')
print ( 2023 )
print( '一共有'  ,  30  ,  '个学生' )

运行结果：

默认地，print在打印完之后会自动换行。如果使它不要换行，则指定 end 参数

print('hello',end = '')
print('world',end = '')

运行结果：

2.2 缩进与注释

Python中，对代码的缩进有严格的要求。后一行代码，必须与前一行对齐。
顶格写，不能加空格或者TAB。不然会有如下报错：

注释，即在代码中插入一些备注说明
快速注释多行： 选中多行后按下 CTRL + /

第三章

3.1 变量

变量，用一个符号表示一个数据
eg:

a = 10

其中，a 称为变量名，10称为变量的值

变量的名字：

• 可以有下划线
• 可以有数字，但不能以数字开头
• 可以有中文
• 不能有空格，也不能有其他特殊符号
• 变量名，区分大小写

3.2 变量的赋值和类型

赋值，就是给变量一个新的值,也可以进行算术运算（先定义一个变量，然后才能使用）
Python中的变量，内部有一个类型
三种常见的数据类型：

数据类型	例子
整数 int ( Integer )	amount = 10
小数 float ，也称浮点数	price = 18.8
字符串 str ( String )	name = ‘铅笔’

#int
amount = 10
#float
price = 18.8
#str
name = '铅笔'

第四章

4.1 算术运算

算术运算，即加、减、乘、除运算
例如，
c = a + b
其中，a + b 称为表达式，+ 称为运算符
算术运算包括以下几种：

运算符	意义
+	加法
-	减法
*	乘法
/	除法
%	模 （除法，取余数 ）
**	幂 ( a ** b 即 a的b次幂 ）
//	整除 ( 除法，向下取整 ）

举一个整除的例子：

a = -12
b = 10
c = a//b
print(c)

运行结果：

说明：a/b=-1.2,-1.2向下取整为-2
细节：//和**是一个整体，中间不能加空格，否则有如下报错:

4.2 组合赋值

赋值与算术运算符，可以组合在一起使用

组合操作符	说明
+=	a += b 相当于 a = a + b
-=	a -= b 相当于 a = a - b
*=	a *= b 相当于 a = a * b
/=	a /= b 相当于 a = a / b
%=	a %= b 相当于 a = a % b
**=	a **= b 相当于 a = a ** b
//=	a //= b 相当于 a = a // b

举一个求幂的例子：

a = 12
b = 2
a **= b
print(a)

运行结果：

说明：a **= b等价于a = a ** b (12的2次方为144)
细节：组合操作符是一个整体，中间不能加空格，否则出现如下报错：

第五章

5.1 单步调试

一个程序是由很多行组成的，一行即一步
单步调试，即一步一步执行，以手工受控的方式来运行

• 在代码中，在某行或多行添加断点Breakpoint
• 右键，以调试方式运行
• 单步，F8
• 停止运行

其中，断点Breakpoint，停止点、刹车点
程序自动运行，并在Breakpoint位置暂停下来
在单步状态下，观察变量的值或类型
1.鼠标移到变量上，直接查看
2.在变量面板里查看
3.每一行的后面，也有显示

eg：
每一行的后面：

鼠标移到变量上

变量面板里

其中，蓝色表示这个变量刚才有了变化

5.2 异常

异常Exception ，意外之事，本不该发生的事情，描述了各种可能发生的意外。
例如，
除零异常 ZeroDivisionError

a = 3/0

异常如下：

异常溯源 Traceback ，哪儿出的错，及调用路径

5.3 抛出异常

当检测到异常发生时，可以报告出来 (抛出)

a = 0
if(a == 0):
    raise Exception('分母不能为0！')
a = 1/a

运行结果如下：

其中，
raise ，可以报告一个异常对象
与return类似，但是更严厉，直接退出程序

第六章

6.1 比较运算符

比较运算符，也叫关系运算符，比较两个数的大小关系

运算符	意义
>	a > b 判断a是否大于b
>=	a >= b 判断a是否大于或等于b
<	a < b 判断a是否小于b
<=	a <= b 判断a是否小于或等于b
==	a == b 判断a是否等于b
!=	a != b 判断a是否不等于b

6.2 逻辑运算符

逻辑运算符，表示‘并且、或者、不’这三种逻辑

运算符	示例	意义
and	a and b	a成立，并且b成立
or	a or b	a成立，或者b成立
not	not a	将a的结果取反

6.3 布尔类型

布尔类型 bool ，表示逻辑上的‘是’与‘否’
例如，
喜欢 True / 不喜欢 False
VIP用户 True / 普通用户 False
其中， True / False 是关键词，表示‘是’/‘否’
所有的表达式，都有一个运算结果

eg:

a = 3 > 4
print(a)
b = 4 < 5 and 3 > 2
print(b)
c = not (2 > 1)
print(c)

运行结果：

调试的变量面板里看得到a,b,c的类型与值

第七章

7.1 if条件判断

if ，用于实现条件判断的逻辑
形如：
if ( 条件 ) :
	子句1
	子句2
	子句...

eg:

#某游戏要求玩家年龄在18岁以上才能登录,否则提示‘不允许登录’

age = 15
if(age < 18):
    print('不允许登录')
print('end')

运行结果：

一般来说，PyCharm 自动为我们保持缩进
也可以按 TAB(向后缩进) 或 SHIFT + TAB（向前缩进）来调节缩进
Python对缩进有严格的要求，if 的子句必须严格保持缩进一格

7.2 if…else…

if..else.. ，表示‘如果.. 否则..’的逻辑
形如，
if ( 条件 ) :
	语句...
else :
	语句...

在 if 逻辑中：‘成立’ True ，‘不成立’False

eg:

# 某游戏要求玩家年龄在18岁以上才能登录。
# 如果大于等于18岁，提示欢迎信息。否则提示‘不允许登录’。

age = 20
if(age >= 18):
    print('欢迎')
else:
    print('不允许登录')

运行结果：

if 语句中的小括号可以省略。
例如，
if ( a > b ) :
可以写成：
if a > b :
eg:

age = 15
if age >= 18:
    print('欢迎')
else:
    print('不允许登录')

运行结果：

7.3 pass语句

pass表示空语句，什么都不做
用于占位，保持结构的完整性
eg:

#某游戏要求玩家年龄在18岁以上才能登录,否则提示‘不允许登录’

age = 15
if(age >= 18):
    pass
else:
    print('不允许登录')
print('end')

运行结果：

（不加pass时会报错）

7.4 if…elif…else

if..elif..else.. ，多重条件判断的逻辑 ( elif 即 else if )
形如，
if ( 条件1 ) :
	语句...
elif ( 条件 2 ):
	语句...
elif ( 条件 3 ):
	语句...
else :
	语句...

eg:

# 某次考试分数评级:A/B/C/D四级。A(90及以上)B(80-90)C(70-80)D(70以下)。
# 已知一个学生的分数，判断它的评级。

score = 78
if(score >= 90):
    print('A')
elif(score >= 80):
    print('B')
elif(score >= 70):
    print('C')
else:
    print('D')

运行结果：

多重条件，按顺序判断。
当满足一个条件后，后面的条件不再继续。

7.5 if的嵌套

在 if 逻辑中，还可以再嵌套 if

if (...) :
	语句...
else :
	语句...

eg:

# 某次考试分数评级:A/B/C/D四级。A(90及以上)B(80-90)C(70-80)D(70以下)。
# 已知一个学生的分数，判断它的评级。

score = 78
if(score >= 70):
    if(score >= 90 ):
        print('A')
    elif(score >= 80):
        print('B')
    else:
        print('C')
else:
    print('D')

运行结果：

第八章

8.1 列表

列表List ，是一个容器类型，表示一列数据
例如，
name_list = [ ‘铅笔’ , ‘钢笔’, ‘橡皮擦’ ]
其中，name_list是一个列表，里面有3个元素。
eg:

name_list = ['铅笔' , '钢笔' , '橡皮擦']
print(name_list)

运行结果：

访问列表中的元素 ，例如，

a = [ 1 , 2 , 3 , 4 ]
则(计数是从0开始的)
a[0] 表示第一个元素  a[1]表示第二个元素 a[2]表示第三个元素

其中，0, 1, 2 , …, N-1 称为元素的索引 ( 下标 )
在Python里面，支持负数的索引 -1， -2，-3…
a[-1] ，指倒数第1个元素
a[-2] ，指倒数第2个元素

a = [ 1 , 2 , 3 , 4 ]
print(a[0])
print(a[-1])

运行结果：

8.2 增加和删除操作

求列表的长度，即元素的个数

a = [ 1 , 2 , 3 , 4 ,5]
size = len(a)
print(size)

其中，len是一个内置函数。
len函数会计算元素的个数，并返回一个值。
运行结果：

在列表末尾，附加一个元素：

a = [ 1 , 2 , 3 , 4 ,5]
a.append(6)
print(a)

运行结果：

在列表中间插入一个元素：

a = [ 1 , 2 , 3 , 4 ,5]
a.insert(0,0)
print(a)

运行结果：

其中，append和insert都是列表类的内置函数

从列表中删除元素：

a = [ 1 , 2 , 3 , 4 ,5]
del a[1]
print(a)
#其中，del a[1] 表示删除[1]号元素（第二个元素）

运行结果：

从列表中删除第二个和第三个元素：

#从列表中删除第二个和第三个元素（错误方法）
a = [ 1 , 2 , 3 , 4 ,5]
del a[1]
del a[2]
print(a)

运行结果：

不符合要求，因为执行一次del a[1]后列表变为[1,3,4,5],此时a[2]为4

应改为：

#从列表中第二个和第三个元素(正确1)
a = [ 1 , 2 , 3 , 4 ,5]
del a[2]
del a[1]
print(a)

或

#从列表中第二个和第三个元素(正确2)
a = [ 1 , 2 , 3 , 4 ,5]
del a[1]
del a[1]
print(a)

运行结果均为：

8.3 子列表

子列表，即列表的子集

a = [ 1 , 2 , 3 , 4 ,5]
sub =a[1:4]
print(sub)

其中，a[1:4] 包含： a[1] 、a[2]、a[3] 共三个元素（不含 a[4]）

运行结果：

更多写法:

a = [ 1 , 2 , 3 , 4 ,5]
b = a[ : 2 ]
c = a[ 2 : ]
d = a[ -2 : ]
e = a[ : -2 ]
print(b)
print(c)
print(d)
print(e)

其中，
a [ 2 : ]  表示 a[2] , a[3] , a[4] 
a [ : 2 ]  表示 a[0] , a[1]  (不含 a[2])
a [ -2 : ]  表示 a[3] , a[4] 
a [ : -2 ]  表示 a[0] , a[1],a[2](不含a [3])

运行结果：

第九章

9.1 字符串的比较与去除空白字符

字符串String，即一串字符串（可以单引号，也可以用双引号）
eg:

name = 'li ming'
city = "荆州"
print(name)
print(city)

运行结果：

输出多行字符串，用三引号（第一行加\顶部少输出一次换行）

introduce = '''\
ni hao
我是李明
来自荆州
'''
print(introduce)

运行结果：

字符串长度，即字符个数
其中，函数 len() 可以求字符串中的字符个数
eg:

str = 'li,ming 荆州'
size = len(str)
print(size)

无论是中文字符、英文字符、标点符号,空格符号，是算作一个字符
运行结果：

字符串拼接：直接用 + 号
eg:

s1 = 'li'
s2 = ' ming'
s3 = s1+s2+'荆州'
print(s3)

运行结果：

比较两个字符串是否相同，用==判断（注意，区分大小写）
eg:

s1 = 'yes'
s2 = 'yes'
if(s1 == s2):
    print('相等')
else:
    print('不相等')

运行结果：

判断是否以xxx开头：

name ='li ming'
if(name.startswith('li')):
    print('ok')

其中，str.startswith (xxx)用于判断 str是否经xxx开头（区分大小写）
运行结果：

同理，str.endswith(xxx)用来判断是否以xxx结尾（区分大小写）：

name = 'li ming'
if (name.endswith('ming')):
    print('ok')

运行结果：

一个字符串左右有空格字符，可以用strip函数去除。

str = '  hello  world  '
str2 = str.strip()
str3 = str.lstrip()
str4 = str.rstrip()
print(str2)
print(str3)
print(str4)

其中，
strip() 去除左右两侧的空白字符，返回新的字符串
lstrip() 仅去除左侧的空白字符
rstrip() 仅去除右侧的空白字符
运行结果：

判断一个字符串是否全是空格：

s = '     '
if ( len ( s.strip() ) == 0) :
	print('全是空白字符')

运行结果：

9.2 大小写转化与字符转义

英文字母的大小写转换：

name = 'Li Ming'
name = name.lower()
print(name)
name = name.upper()
print(name)

中文和标点符号没有大小写之分，只适用于英文字母 a-z
其中，先执行右侧的函数，再把结果赋给左侧变量
运行结果：

字符转义，一种对特殊字符的处理
当一个字符串中，包含以下字符时，需特殊处理

字符	转义	说明
’	\’	单引号
“	\"	双引号
\	\\	反斜杠
换行	\n	换行
制表	\t	缩进

eg:

str1 = 'C:\\data\\python3.zip\n'
#输出C:\data\python3.zip并换行
print(str1)
#输出nihao,'lihuanying"
str2 = 'nihao,\'lihuanying\"'
print(str2)

运行结果：

9.3 子串查找与字符串转数字

字符串，一串字符，相当于一个列表

str = 'liming'

取得子串，和列表操作类似:

str ='liming'
print(str[2:4])

运行结果：

查找子串find() ，在一个字符串中，查找一个子串

url = 'http://wuststudy.cn/java/index.html'
p1 = url.find('wust')
p2 = url.find('kk')
print(p1)
print(p2)

其中，str.find ( substr ) 从头开始查找，用于查找子串的首次出现的位置
若未找到，则返回 -1
运行结果：

find 还有几种用法，可以指定查找的范围:

• find ( substr, start ) ，从 start处开始查找
• find ( substr, start, end) ，在 start ~ end 范围之间查找
  eg:

url = 'http://wuststudy.cn/java/index.html'
p1 = url.find('u')
p2 = url.find('u' , 10)
p3 = url.find('u' , 18 , 20)
print(p1)
print(p2)
print(p3)

运行结果：

综合练习，在URL中截取主机地址（wuststudy.cn）

url = 'http://wuststudy.cn/java/index.html'
p1 = url.find('//')
p2 = p1 + 2
p3 = url.find('/' , p2)
print(url[p2 : p3])

运行结果：

思考，以下代码有什么问题？

#错误比较
age = '18'
if (age > = 18):
    print('成年')

运行一下报错：

TypeError ，类型错误，不同类型之间，不可以直接比较
‘18’ 字符串类型 ( str ) 18 整数类型 (int )
不同类型之间不能直接比较，先转成数字类型

#字符串  数字
age = int ('18')
price = float ('13.4')
#数字  字符串
s = str (18)
if(age >= 18):
    print('成年')
if(s == '18'):
    print('18岁了')

运行结果：

9.4 字符串的分割与格式化

split() ，用于字符串的分割

birthday = '2001-7-18'
ymd = birthday.split('-')
print(ymd)

其中，ymd是一个列表，里面有3个String元素
运行结果：

字符串的格式化：
三种替换方式：
1.按顺序替换

str ='名称是{},价格:{} 数量:{}'.format('铅笔' , 2.8 , 12)
print(str)

注意：{}内不能加空格，否则会报错
运行结果：

2.按索引替换

str = '{0} {1} {1},{0}'.format('hello','world')
print(str)

同样地，{0}内不能加空格，否则会报错
运行结果：

3.按参数名替换

str = '名称:{name},价格:{price}'.format(name = '铅笔' , price = 2.8)
print(str)

同样地，{name}内不能加空格，否则会报错
运行结果：

整数的格式化：在大括号里，用冒号指定显示格式
1.左侧补空格，宽度为4

num = 12
str ='值为:{:4d}'.format(num)
print(str)

注意：{:4d}内不能加空格，否则会报错
运行结果：

2.左侧补零，宽度为4

num = 12
str ='值为:{:0>4d}'.format(num)
print(str)

同样地，{:0>4d}内不能加空格，否则会报错
运行结果：

3.千分位显示

num = 12345678
str = '值为 {:,}'.format(num)
print(str)

同样地，{:,}内不能加空格，否则会报错
运行结果：

浮点数的显示（eg:保留两位小数）

num = 1.345
str = '值为:{:.2f}'.format(num)
print(str)

注意：{:.2f}内不能加空格，否则会报错
运行结果：

大括号的转义(eg:在字符串中显示大括号)

str = '显示大括号: {{dakuohao}} '.format()
print(str)

注意：{{dakuohao}}内不能加空格，否则会报错
运行结果：

混合使用一下：

str1 = '{:.2f} {:0>4d} {:,} 名称是{name}'.format(3.12345,123,12345678,name ='呵呵')
print(str1)
str2 = '{0:.2f},{1:0>4d} {2:,} {3}'.format(1.286,22,12345678,'nihao')
print(str2)

运行结果：

第十章

10.1 while循环以及遍历

while ，用于实现循环逻辑

	while ( 条件 ) :
		语句
	其中，当条件为True时，执行循环体。反复执行。

eg:打印显示1~100 间的 7 的倍数

i = 1
sum = 0
while (i <= 100):
    if(i % 7 == 0):
        sum += i
    i=i+1
print(sum)

其中，一般可以把 i 叫做循环变量，或迭代变量。
运行结果：

遍历，指对列表中的元素逐一访问（从前往后，或者从后往前）
从前往后遍历：

list = [12,23,5,6]
i = 0
while(i < len(list)):
    print(list[i])
    i+=1

运行结果：

从后往前遍历：

list = [12,23,5,6]
i = len(list)-1
while(i >= 0):
    print(list[i])
    i-=1

运行结果：

10.2 break语句

break 语句，用于终止循环
用在循环体中，一般表示当某条件发生时，结束循环
eg:返回列表中第一个值为23的下标

list = [12,23,5,6,23]
i = 0
while(i < len(list)):
    if(list[i] == 23):
        print(i)
        break
    i+=1

运行结果：

注：break 语句必须放在循环体中使用，否则毫无意义。

10.3 continue语句

continue 语句，放弃本轮，但循环仍然继续
eg:寻找列表中所有值为23的下标：

list = [12,23,5,6,23]
i = 0
while(i < len(list)):
    if(list[i] == 23):
        print(i)
        i+=1
        continue
    i+=1

注意: continue前面，应该加上循环迭代
运行结果：

10.4 for循环

for遍历，是 while 遍历的简化形式
eg:for遍历输出列表中所有元素

list = [12,23,5,6,23]
for item in list:
    print(item)

运行结果：

10.5 range遍历

range（）是一个函数，用来返回一个迭代对象，在实际使用当中range经常搭配for语句使用。
（1）range (end）
eg:

for i in range(6) : 
    print( i )

其中，range(6) 指定一个数字范围，与for联用，默认起始值为0,实现从0到6的遍历。（不包括6）。
运行结果：

（2）range (start,end）
eg:

for i in range(2, 6) :
    print( i )

其中，range(2,6) 指定一个数字范围，与for联用，实现从2到6的遍历。（不包括6）。
运行结果：

（3）range (start, end, step)
eg:

for i in range(0, 10, 3) :
    print( i )

其中，实现从0到10的遍历，每次步长加3。
运行结果：

第十一章

11.1 函数

函数Function ，表示一个功能

例如，
print ( str ) ，用于打印输出
size = len ( list ) ，用于求列表的长度
s = str.split( '-' ) ，用于字符串的分割

Python自带的函数，一般称为 API ( 库函数，系统函数 )
几个常见的函数：

函数	作用
abs(x)	求x的绝对值
round(x, n)	对浮点数x四舍五入，保留n位小数
max (x, y, z…)	求 x, y, z, … 的最大值，也可以传一个列表参数
min (x, y, z…)	求 x, y, z … 的最小值，也可以传一个列表参数

下面来测试一下这几个函数：

a = -1.6
b = 3.4567
c = abs(a)
d = round(b,2)
e = max(3,5,4,8)
f = min(3,5,4,8)
list_1 = [3,5,4,8]
g = max(list_1)
h = min(list_1)
print(c)
print(d)
print(e)
print(f)
print(g)
print(h)

运行结果如下：

11.2 数学函数和随机函数

在使用数学函数时，需要先导入 math模块
import math
math.pi 表示圆周率常量π
π（圆周率）≈3.1415926…
math.e ，代表数学的自然常量 e
e（自然对数的底）≈2.7182818…

函数	作用
degrees(x)	将弧度x转换成角度值
radians(x)	将角度x转换成弧度值
sin(x)	求弧度x的正弦值
cos(x)	求弧度x的余弦值
tan(x)	求弧度x的正切值
asin(x)	求弧度x的反正弦值
acos(x)	求弧度x的反余弦值
atan(x)	求弧度x的反正切值
exp(x)	求ex
log(x, a)	求 log以a为底x对数的值
log10(x)	求 log以10为底x对数的值
pow(a, x)	求ax ，相当于 a**x
sqrt(x)	求 x 的平方根
ceil(x)	向上取整
floor(x)	向下取整

下面来测试一下这几个函数：

import math

degree = 30
radian = math.radians(degree)
radian_2 = 0.5
degree_2 = math.degrees(radian_2)
print(degree_2)
print(radian)
print(math.sin(radian))
print(math.cos(radian))
print(math.tan(radian))
print(math.asin(radian))
print(math.acos(radian))
print(math.atan(radian))
print(math.exp(2))
print(math.log(8,2))
print(math.log10(100))
print(pow(3,3))
print(math.sqrt(36))
print(math.ceil(3.55))
print(math.floor(3.55))
print(math.pi)
print(math.e)

运行结果：

随机函数，定义在random模块中
其中，常见的三个函数：
random.random() ，生成随机数 [0, 1)
vv = random.choice (list) ，从列表中随机选择一个元素
random.shuffle(list) ，随机洗牌，打乱列表中的元素

#random.random() ，生成一个随机数，介于[0, 1) 之间,不包括1
import random
rad =random.random()
print(rad)

运行结果：

注：每次运行结果可能不一样

#random.choice (list) ，从 list 中随机抽选一个元素
import random
list = ['a','b','c','d','e']
print(random.choice(list))

运行结果：

注：每次运行结果可能不一样

#random.shuffle(list) ，洗牌算法，随机打乱元素的顺序
import random
list = ['a','b','c','d','e']
random.shuffle(list)
print(list)

运行结果：

注：每次运行结果可能不一样

11.3 自定义函数

自定义函数，就是自己定义 (Define) 一个函数
例如：

def test():
    print('this is a fuc')

其中，定义了一个函数，名为 test
先定义，后调用（函数定义，放在代码的最上面）

def test():
    print('this is a fuc')
test()

运行结果：

参变量，即函数的参数，在小括号里声明。
例如：

def my_print ( cnt ) :
    i = 0
    while ( i <= cnt ) :
        print(i)
        i += 1
my_print(3)

其中， cnt为函数的参变量

my_print(3)也可以写成my_print(cnt = 3)

运行结果 ：

一个函数，也可以有多个参数。
例如：

def my_print (start,end) :
    i = start
    while ( i <= end ) :
        print(i)
        i += 1
my_print(3,5)

其中，start为起始，end为结束
多个参数的传递：
1 无名，按顺序传递
my_print ( 3, 5 )
2 有名，顺序不限
my_print (start=3, end=5)

my_print(3,5)也可以写成 my_print (start=3, end=5)

运行结果：

一个函数，表示一个功能、一件事情。
返回值，即该函数运算的结果。
例如定义一个函数，求一个列表的各项之和：

def get_sum(list):
    sum = 0
    for item in list:
        sum += item
    return sum
list = [1,2,3,4,5]
value = get_sum(list)
print(value)

其中，return sum表示将一个值返回给调用者
运行结果：

提前返回 ，当结果出现之时，可以立即返回
例如寻找第一个值为3的元素下标（如果找不到返回-1）：

def findvalue(list,value):
    i = 0
    while(i < len(list)):
        if(list[i]==value):
            return i
        i += 1
    return -1
list = [1,3,5,3,5]
index = findvalue(list,3)
print(index)

其中，

• 有匹配项，则立即 return 返回；
• 无匹配结果，则默认返回 -1

return ，可以返回各种类型的数据

• None ( 不返回数据 )
• int , float, str
• bool
• list …
  有的函数不返回数据，例如:

def test():
	print('this is a fuc')

练习寻找所有值为3的元素下标（如果找不到返回-1）：

def findvalue(list,value):
    i = 0
    list_2 = []
    while(i < len(list)):
        if(list[i]==value):
            list_2.append(i)
        i += 1
    if(len(list_2)):
        return list_2
    return -1
list = [1,3,5,3,5]
index = findvalue(list,3)
print(index)

运行结果：

函数返回值直接使用：
eg:

list = [ 12, 3, 5, 9]
size = len (list)
print ('长度', size )

可以直接写成:

print('长度',len(list))

其中，len(list) 的返回值，作为一个值直接使用。
在函数里临时定义的变量，为局部变量。
在函数外部定义的变量，为全局变量。

def test():
    a = 3
    print(a)

其中，a称为局部变量
局部变量是临时的，在函数完成时消失。因此，不能在外面访问局部变量。

test()
print (a) ???

否则有如下报错：

局部变量和全局变量重名时，在函数内部把局部变量全局变量覆盖掉了

a = 10  # 全局变量
def example( ) :
    a = 3 # 局部变量
    print('里面，局部变量 =' , a)
example()
print('全局变量 =' ,a)

运行结果：

使用global关键字声明时外面的全局变量

a = 3  # 全局变量
def example( ) :
    global a  # 声明a指的是外面的全局变量
    a = 6
    print('里面，全局变量=' , a)
example()
print('全局变量=' ,a)

此时a = 6 将之前的全局变量覆盖了
运行结果：

函数重名时

def test():
    print('this is a fuc')
def test():
    print('this is a fuc2')
test()

其中，后一个 test() 覆盖了前一个test()的定义
运行结果：

第十二章

12.1 自定义模块

自定义的模块，就是把若干函数定义集中在一起
例如，
1 新建一个 test.py
2 在 test.py 中 添加一些函数和变量
3 在 main.py 中导入 import test
在test.py 中：

def testfuc():
    print('This is a test')

str = 'This is a str'

在main.py中调用：

import test
test.testfuc()
print(test.str)

运行结果如下：

模块名即文件名，也可以用中文。
把相关的函数放在一起

• 方便管理
• 重复利用

12.2 符号导入

符号导入 ，一种加强版的导入
例如，
from test import testfuc,str
从 test 模块中，导入 testfuc 和 str
from test import *
从 test 模块中，导入所有符号
在test.py 中：

def testfuc():
    print('This is a test')
str = 'This is a str'

在main.py中调用：

from test import testfuc,str
testfuc()
print(str)

运行结果如下：

区别
import test：导入之后，仍需加上前缀调用：test.testfuc()
from simple import testfuc ：导入之后，不加前缀调用：testfuc ()

12.3 类型声明

类型声明Typing ，帮助编辑器来自动提示

添加类型声明
1.参变量类型
def your_func(arg1:int, arg2:list, arg3:str ) :
2.变量类型
size:int = len(list)
3.函数返回值类型（ 默认地，PyCharm从代码中推断返回值类型也可以显式声明）
def your_func ( … ) -> str :

不加类型声明，不影响程序的运行。

泛型声明，即元素类型的声明

形如，
arg : list[int]
arg : list[str]
arg : list[float]

12.4 自定义类型

Python自带的类型int, float, str, bool...
也可以定义自己的类型，称为类class

1.添加一个模块 stu.py
2.添加一个类型定义

class student:
    name = ''
    no = 000
    age = 0
    sex = True
    def test(self):
        print('this is a test')

3.导入 from stu import *
4.创建一个学生对象

from stu import *
stu = student()
stu.name = '小明'
stu.no = 123
stu.age = 18
stu.sex = True
print(stu.name,stu.no,stu.age,stu.sex)
stu.test()

运行结果如下：

其中，
stu = student() ，构造函数，构造一个 student 对象
stu.name称为属性，也称为字段
类中的字段定义，要保持缩进

第十三章

13.1 元组

元组 tuple ，也是表示一组元素，元组使用小括号

tp = (10,1,2,8)#此处为小括号
a = tp[0]
print(a)
all = tp + (5,6,7) #元组可以‘相加’
size = len(all) #计算元组长度
print(size)
for item in all:
    print(item)

运行结果如下：

tuple ，相当于只读的list，不支持增、删、改

data[0] = 12  # ?? 不支持

否则会有如下报错：

13.2 元组和列表

元组 tuple VS 列表 list
1 tuple 用小括号, list 用中括号
data = ( 20, 9, 5 )
abc = [ 20, 9, 5 ]
2 tuple 是只读的，不能增删改
3 其他区别

tuple 与 list 的转换
元组 -->列表

data = ( 20, 9, 5 )
abc = list ( data )

列表 -->元组

abc = [ 20, 9, 5]
data = tuple ( abc )

一般来说，我们使用list即可
但是，有的 API 库函数的要求使用tuple类型

第十四章

14.1 日期处理

时间处理 datetime 模块

datetime ，年月日时分秒
date ，年月时
timedelta，时间差

首先

from datetime import *

date类，代表一个日期数据，年、月、日
1.构造一个日期对象

d1 = date(2006,9,1)
print(d1)

运行结果如下：

2.当前日期

d2 = date.today()
print(d2)

运行结果如下：

3.获取年、月、日

d3 = date.today()
print(d3.year,d3.month,d3.day)

运行结果如下：

4.修改日期

d1 = date(2006,9,1)
d1 = d1.replace(year = 2019 ,month = 12 ,day=20)
print(d1)
#d1.year = 2000 错误，d1.year只读

运行结果如下：

其中，date中的三个属性 year, month, day 是只读的

14.2 日期的格式化

1.date -->str

d1 = date.today()
datestr = d1.strftime("%Y年%m月%d日")
print(datestr)

运行结果如下：

其中，strftime ( 即 string format time ) 用于格式化
%Y 年份，%m月，%d日 ，注意大小写
2.str --> date

datestr2 = '2023/7/29'
dt = datetime.strptime(datestr2,'%Y/%m/%d')
d2 = dt.date()
print(d2)

运行结果如下：

其中，strptime ( 即 string parse time ) 用于解析提取
先用datetime解析得到一个 datetime 对象，然后再获取 date 对象
常用的格式符：(区分大小写)

格式符	意义
%Y	年份。如 2023
%m	月份。如 01, 02, 03, …, 12
%d	几号。如 01, 02, 03, …, 31
%H	时钟。如 01, 02, 03, …, 23
%M	分钟。如 01, 02, 03, …, 59
%S	秒钟。如 01, 02, 03, …, 59
%w	星期几。如 0, 1, 2, …, 6 。周日为0，周一为1，…
%j	一年中的第几天。如001, 002, 003, …, 366
%W	一年中的第几周。如01, 02, 03, …, 53

14.3 日期的比较

date类型可以直接比较

d1 = date(2023, 7, 29)
d2 = date(2021, 7, 31)
if (d1 < d2) :
    print('早')
elif (d1 == d2):
    print('一样')
else :
    print('晚')

运行结果如下：

甚至也支持加法和减法操作

d1 = date(2023, 7, 29)
d2 = date(2023, 9, 9)
delta = d2 - d1
print('相差的天数', delta.days)

运行结果如下：

timedelta类型，表示时间差值
eg：计算100以后的日期

d1 = date(2023, 7, 29)
td = timedelta(days=100)
d3 = d1 + td
print(d3)

运行结果如下：

第十五章

15.1 字典

字典 dict ，与 list 类似，也是一种容器类型
字典里的一条数据，称为键值对
Key --> Value
Key 用于代表一条数据，即索引

创建字典对象，用大括号

nn = {} #创建一个空字典
nn[100] = '张三'
nn[101] = '李四'
nn[102] = '王五'

其中，nn[key] = value 是向nn中添加一个值，索引为key(添加键值key重复时新值会覆盖旧值)

从字典中检索一个Key的值

value = nn.get(102)
if (value is None ):
    print('查无此人')
else:
    print(value)

运行结果如下：

其中，get(…) 函数传入一个Key值 ，若不存在则返回 None
也可以使用另一种写法（不安全）：

value = nn[202]
print(value)

也可以检索 key为202的值。若不存在，则报告异常
不存在时报告异常：

15.2 字典的查询与删除

查询一个 Key 在字典中是否存在
形如：

if ( key in dict ) :

if(101 in nn):
    print('存在')
else:
    print('查无此人')

运行结果如下：

从字典中删除一项

del dict[key]

更安全的写法：

if(101 in nn):
    del nn[101]
print(nn)

运行结果如下：

字典的主要作用，是用于快速检索

value = dict.get(key)

字典可以存几十条数据，也可以存几万条，不太影响查询速度
内部采用哈希算法，非线性查找

第十六章

16.1 控制台输入

控制台 Console ，即命令行终端
例如：
str = input ( prompt )
控制台里只能使用键盘输入，不支持鼠标

input 与 单步调试：
input() 执行时，用户在控制台里即可输入
此时，单步调试不可前进，程序卡在控制台里

获取输入后，通常 strip 一下，用 strip 来去除两侧多余的空白字符

user = input('用户名:')
pwd = input('密码:')
pwd = pwd.strip()
if(pwd == '123'):
    print('密码正确')
else:
    print('密码错误')

运行结果如下：

（完结撒花★,°:.☆(￣▽￣)/$:.°★* 。）***