python学习笔记

第一个python程序

pycharm使用

pycharm下载链接：
https://www.jetbrains.com/zh-cn/pycharm/download/#section=windows

1. 新建项目

右键test—> 点击new


输入文件名

运行

结果

2. 调节字体大小快捷键设置

右键添加鼠标快捷键


按住ctrl+鼠标向上滑动 放大字体

按住ctrl+鼠标向下滑动 缩小字体

3. 设置中文

4. 内置翻译插件安装

5. 常用快捷键

CTRL+/全部注释

python第二章：python基础语法

1. 字面量

1. 含义
   在代码中，被写下来的的固定的值，称之为字面量
2. 常见数据类型

2. 注释

# 单行注释

"""
多行注释
"""
1
2
3
4
5

3.变量

1. 变量的含义: 在程序运行时，能储存计算结果或能表示值的抽象概念。简单的说，变量就是在程序运行时，记录数据用的

2. 定义格式：
   

3. 特征
   变量值可以改变

4. 练习
   

money = 50
print("钱包：",money)
icecream = 10
print("买冰淇淋：",icecream)
cola = 10
print("买可乐：",cola)
money = money - icecream - cola
print("钱包：",money)
1
2
3
4
5
6
7
8

4.数据类型

1. type()语句
   

print(type(666))
print(type("666"))
print(type(3.3))
1
2
3

2. 变量有类型吗?
   我们通过type(变量)可以输出类型，这是查看变量的类型还是数据的类型?

查看的是:变量存储的数据的类型。
因为，变量无类型，但是它存储的数据有。

5. 数据转换

数据类型转换，将会是以后经常使用的功能。
如:

• 从文件中读取的数字，默认是字符串，我们需要转换成数字类型

• input()语句，默认结果是字符串，若需要数字也需要转换

• 将数字转换成字符串用以写出到外部系统

int(x)
将x转换为一个整数
float(x)
将x转换为一个浮点数
str(x)
将对象×转换为字符串
1
2
3
4
5
6

6. 标识符

命名规则：

1. 内容限定（不能数字开头）
   标识符命名中，只允许出现:
   英文
   中文
   数字
   下划线（_)
   这四类元素。
2. 大小写敏感
3. 不可使用关键字

7. 运算符

1. 算术运算符
   

print(1+1)
print(2-1)
print(3*3)
print(3/3)
print(11//2)
print(9%2)
print(2**3)
1
2
3
4
5
6
7

结果：
2
1
9
1.0
5
1
8
1
2
3
4
5
6
7
8

2. 赋值运算符
   
   3.复合赋值运算符
   

8.字符串的扩展

8.1字符串的定义形式

字符串在Python中有多种定义形式:
1.单引号定义法: name ='666'
2.双引号定义法: name ="666"(最常用)
3.三引号定义法:name = """666"""

三引号定义法，和多行注释的写法一样，同样支持换行操作。使用变量接收它，它就是字符串
不使用变量接收它，就可以作为多行注释使用。

字符串的引号嵌套
思考:如果我想要定义的字符串本身，是包含:单引号、双引号自身呢?如何写?
·单引号定义法，可以内含双引号
·双引号定义法，可以内含单引号
·可以使用转移字符\ 来将引号解除效用，变成普通字符串

8.2 字符串的拼接

+号拼接

不过一般，单纯的2个字符串字面量进行拼接显得很呆，一般，字面量和变量或变量和变量之间会使用拼接

pinjie="sweetie"
print(pinjie+"yyds")
1
2

8.3字符串格式化

8.3.1 字符串格式化

语法：

%占位符"%变量
1

tips：多个变量占位
变量要用括号括起来并按照占位的顺序填入

age=21
personarity="nice"
she="她的年纪是%s,她性格:%s" %(age,personarity)
print(she)
1
2
3
4

age=21
personarity="nice"
she="她的年纪是%d,她性格:%s" %(age,personarity)
print(she)
1
2
3
4

8.3.2 格式化方式2

f"内容{变量}"
1

age=21
personarity="nice"
print(f"她的年纪是{age},她性格:{personarity}")
1
2
3

这种方式:
·不理会类型
·不做精度控制
适合对精度没有要求的时候快速使用

8.3.5对表达式进行格式化

表达式:一条具有明确执行结果的代码语句

f"(表达式}"
"%s%d\%f" %(表达式、表达式、表达式)
1
2

9. input语句

1. input()语句的功能是，获取键盘输入的数据
2. 可以使用: input(提示信息)，用以在使用者输入内容之前显示提示信息。
3. 要注意，无论键盘输入什么类型的数据，获取到的数据永远都是字符串类型

print("who are you")
identity=input()
print("i know it,you are:%s" %identity)
1
2
3

python第三章：判断语句

1.BOOL类型

bool_1=True
bool_2=False
print(f"bool内容：{bool_1},类型：{type(bool_1)}")
print(f"bool内容：{bool_2},类型：{type(bool_2)}")
1
2
3
4

比较运算符的使用

== , !=, >, <,>=,<=
1

num1=10
num2=15
print(f"10!=15 result:{num1!=num2}")
1
2
3

str1="qwer"
str2="asdf"
print(f"str1=str2 result:{str1==str2}")
1
2
3

2.if语句的基本格式

1. if语句的基本格式
   if要判断的条件:
   条件成立时﹐要做的事情

2. if语句的注意事项:
   判断条件的结果一定要是布尔类型
   不要忘记判断条件后的:冒号
   归属于if语句的代码块，需在前方填充4个空格缩进

print("input your age")
age=int(input())
if age>=18:
    print("adult!")

print("children!")
1
2
3
4
5
6

3. if else 语句

1. if else 语句，其中·
   if和其代码块，条件满足时执行
   else搭配if的判断条件，当不满足的时候执行
2. if else语句的注意事项:
   else不需要判断条件，当if的条件不满足时，else执行.
   else的代码块，同样要4个空格作为缩进

age=int(input("input your age:"))
if age>=18:
        print("adult!")
else:
        print("children!")
1
2
3
4
5

4. if elif else语句

1. if elif else语句的作用是?
   可以完成多个条件的判断
   2.使用if elif else的注意点有:
   elif可以写多个
   判断是互斥且有序的，上一个满足后面的就不会判断了
   可以在条件判断中，直接写input语句，节省代码量

num = int(input("guess number:"))
if num>10:
        print("wrong,again")
elif num<10:
        print("wrong,again")
else:
        print("ringht")
1
2
3
4
5
6
7

5.判断语句的嵌套

游乐园规则：身高小于120或VIP级别>3免费

print("welcome to zoo")
height=int(input("intput your height:"))
if height>120:
        print("need 10 yuan")
        print("vip level>3,free")
        if(int(input("tell me your level:"))>3):
                print("free")
        else:
                print("need 10 yuan")
else:
        print("free,children")
1
2
3
4
5
6
7
8
9
10
11

age=int(input("how old are you?:"))
if(age>=18 and age<30):
        print("access!")
        if (int(input("your work year:"))>2):
                print("you got award")
        else:
                print("go on:")
                if(int(input("tell me your level:"))>3):
                        print("you got award")
                else:
                        print("you get nothing")
else:
        print("you get nothing")
1
2
3
4
5
6
7
8
9
10
11
12
13

import random
num = random.randint(1,10)
print(num)
guess = int(input("your number:"))
if guess == num:
        print("bingo")
else :
        if guess > num:
                print("big")
        else:
                print("small")
guess = int(input("your number again:"))
if guess == num:
        print("bingo at twice")
else :
        if guess > num:
                print("big")
        else:
                print("small")
guess = int(input("your number again:"))
if guess == num:
        print("bingo at third")
else :
       print("you got lose")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

python第四章：循环语句

1.while的基础语法

while循环的注意事项：
条件需提供布尔类型结果，True继续，False停止。
空格缩进不能忘
请规划好循环终止条件﹐否则将无限循环

i=0
while i<10:
    print("sweetie yyds")
    i=i+1
1
2
3
4

import random
num = random.randint(1,100)
print(num)
i = 0
flag = True
while flag:
    guess = int(input("you guess:"))
    i = i + 1
    if guess == num:
        print("bingo")
        flag = False
    else:
        if guess > num:
            print("big")
        else:
            print("small")
print(f"guess {i} times")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.while循环的嵌套使用

每天都去向小美表白，送十朵玫瑰
直到成功为止
每次表白的流程是送朵玫瑰然后表白

i = 1
while i <= 15:
    print(f"i love you {i} days")
    j = 0
    while j < 10:
        print("a rose to you")
        j = j +1
    print("love^-^")
    i = i + 1
print(f"{i-1} days,fall in love")
1
2
3
4
5
6
7
8
9
10

补充

在字符串中，有一个特殊符号:\t，效果等同于在键盘上按下: tab键,它可以让我们的多行字符串进行对齐。

print("hello world")
print("sweetie yyds")
print("hello\tworld")
print("sweetie\tyyds")
1
2
3
4

通过两层while循环 打印九九乘法表

i=1
while i<=9:
    j=1
    while j <= i:
        print(f"{i}*{j}={i*j}\t",end ='')
        #print输出不要换行，/t进行对齐
        j = j + 1
    i = i + 1
    print()
    #print 空内容即为换行
1
2
3
4
5
6
7
8
9
10

3.for循环

除了while循环语句外，Python同样提供了for循环语句。两者能完成的功能基本差不多，但仍有一些区别:
. while循环的循环条件是自定义的，自行控制循环条件
. for循环是一种”轮询”机制，是对一批内容进行”逐个处理”

1. 语法：
   for 临时变量 in 待处理数据集
   循环满足条件时执行的代码

遍历字符串：

name = "qwer"
for i in name:
    print(i)
1
2
3

2. for循环的注意点
   无法定义循环条件﹐只能被动取出数据处理要注意﹐循环内的语句﹐需要有空格缩进

j=0
name="itheima is a brand of itcst"
for i in name:
    if i == "a":
        j = j + 1
print(f"a appears {j} times")
1
2
3
4
5
6

3. range语句

range()函数语法:

range(start, stop[, step])
1

参数说明：

• start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
• stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

#range语法1 range(num)
for i in range(10):
    print(i)

#range语法2 range(num1,num2)
for x in range(5,10):
    print(x)

#range语法2 range(num1,num2,step)
for q in range(5,15,3):
    print(q)
1
2
3
4
5
6
7
8
9
10
11

4. continue 和 break

1. 临时中断
   continue关键字用于:中断本次循环，直接进入下一次循环
   continue可以用于:for循环和while循环，效果一致
   

2. 永久中断
   break关键字用于:直接结束循环
   break可以用于:for循环和while循环，效果一致
   

3. 注意事项:
   . continue和break，在for和while循环中作用一致
   ·在嵌套循环中，只能作用在所在的循环上，无法对上层循环
   起作用

综合实验

import random
total = 10000
for bianhao in range(20):
    jixiao = random.randint(1, 10)
    if jixiao < 5:
        print(f"{bianhao}get nothing")
        continue
    if total >= 1000:
        total = total - 1000
        print(f"{bianhao}get salary")

    else:
            print("no money here")
            break
1
2
3
4
5
6
7
8
9
10
11
12
13
14

python第五章：函数

1.函数

1. 函数是:
   组织好的、可重复使用的、用来实现特定功能的代码段
2. 使用函数的好处是:
   ·将功能封装在函数内，可供随时随地重复利用
   ·提高代码的复用性，减少重复代码，提高开发效率

自己定义一个统计字符串长度的函数

str1 = "rtyuiiio"
str2 = "sssssdfghjk"
str3 = "vbnm"

def mylen(data):
    count = 0
    for i in data:
        count = count + 1
    print(f"string {data} length is {count}")

mylen(str3)
mylen(str2)
mylen(str1)
1
2
3
4
5
6
7
8
9
10
11
12
13

2.函数的定义

def say_hi():
    print("hi")
say_hi()
1
2
3

函数的调用:函数名(参数)

注意事项：
参数如不需要，可以省略
返回值如不需要，可以省略
函数必须先定义后使用

3.函数的参数

传入参数的功能是:在函数进行计算的时候，接受外部（调用时）提供的数据

定义一个加法函数add

def add(x,y):
    z = x + y
    print(f"{x}+{y}={z}")
add(2,3)
1
2
3
4

传入参数的数量是不受限制的。
可以不使用参数
也可以仅使用任意N个参数

4. 函数的返回值

def函数(参数…):
函数体
return返回值
变量=函数(参数)

1.什么是函数返回值?
函数在执行完成后，返回给调用者的结果
2.返回值的应用语法:
使用关键字:return来返回结果
3.注意:
函数体在遇到return后就结束了，所以写在return后的代码不会执行,

def add(x,y):
    z = x + y
    return z
r = add(2,3)
print(r)
1
2
3
4
5

None类型
思考:如果函数没有使用return语句返回数据，那么函数有返回值吗
实际上是:有的。
Python中有一个特殊的字面量:None，其类型是:无返回值的函数，实际上就是返回了:None这个字面量
None表示:空的、无实际意义的意思
函数返回的None，就表示，这个函数没有返回什么有意义的内容。也就是返回了空的意思。

def sayhi():
    print("hi")
result = sayhi()
print(f"无返回函数返回内容：{result}")
print(f"无返回函数返回内容：{type(result)}")
1
2
3
4
5

1.什么是None
None是类型’NoneType’的字面量，用于表示:空的、无意义的
2.函数如何返回None
不使用return语句即返回None
主动return None
3.使用场景
函数返回值
. if判断
·变量定义

5. 函数的说明文档

函数是纯代码语言，想要理解其含义，就需要一行行的去阅读理解代码，效率比较低。
我们可以给函数添加说明文档，辅助理解函数的作用。
语法如下:

def func(x，y):
"""
函数说明
: param x:形参x的说明
: param y:形参y的说明
: return:返回值的说明
"""
函数体
return返回值
1
2
3
4
5
6
7
8
9

通过多行注释的形式，对函数进行说明解释。
内容应写在函数体之前

在PyCharm编写代码时，可以通过鼠标悬停，查看调用函数的说明文档

6.函数的嵌套调用

1. 所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数

def print1():
    print("1")

def print2():
    print("2")

    print1()

    print("3")
print1()
print2()
1
2
3
4
5
6
7
8
9
10
11

2. 执行流程
   函数A中执行到调用函数B的语句，会将函数B全部执行完成后，继续执行函数A的剩余内容

7.变量的作用域

变量作用域指的是变量的作用范围(变量在哪里可用，在哪里不可用)
主要分为两类:局部变量和全局变量
所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效

全局变量

num =100
def test():
   
    print(num)
test()
print(num)
1
2
3
4
5
6

使用 global关键字可以在函数内部声明变量为全局变量

python第六章：python数据容器

1. 数据容器

1. 为什么要学习数据容器？
   多个变量存储及使用

2. Python中的数据容器:
   一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
   

3. 数据容器的类型：列表（ list)、元组(tuple)、字符串( str)、集合（set)、字典( dict )

1.1列表

tips:列表可以存储多种变量，并且支持嵌套（列表套列表）

list1 = [[1,2,3],[4,"t",4.5]]
print(type(list1))
print(list1)
1
2
3

1.1.1列表的下标索引

列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增

list1 = [[1,2,3],[4,"t",4.5]]
print(type(list1))
print(list1)
print(list1[0][1],list1[1][1])
print(list1[0][-1],list1[1][-3])
1
2
3
4
5

1.1.2列表的常用操作方法

a. index（嵌套列表不可用）

查找某元素的下标
功能:查找指定元素在列表的下标，如果找不到，报错ValueError

语法:
列表.index(元素)
1
2

index就是列表对象（变量)内置的方法（函数)

mylist = [1,4.3,'flag']
index = mylist.index('flag')
print(f"flag的索引为：{index}")
1
2
3

b.修改列表中的值

语法:
列表[下标]=值
1
2

可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行:重新赋值（修改)

mylist[2] = 2.1
print(mylist)
1
2

c.插入元素

语法:
列表.insert(下标,元素)
1
2

在指定的下标位置，插入指定的元素

mylist.insert(3,666)
print(mylist)
1
2

d.将指定元素加在列表尾部

• 追加元素方式1:

语法:
列表.append(元素)
1
2

将指定元素，追加到列表的尾部

• 追加元素方式2:

语法:
列表.extend(其它数据容器)，
1
2

将其它数据容器的内容取出，依次追加到列表尾部

mylist.extend([2,22,222])
print(mylist)
1
2

mylist1= [2,22,222]
mylist.extend(mylist1)
print(mylist)
1
2
3

e.删除元素

语法1:del 列表[下标]
语法2:列表.pop(下标)
1
2

mylist = [1,4.3,'flag']
del mylist[1]
mylist.pop(1)
print(mylist)
1
2
3
4

删除某元素在列表中的第一个匹配项

语法:
列表.remove(元素)
1
2

mylist = [1,4.3,'flag',1]
mylist.remove(1)
print(mylist)
1
2
3

f. 清空列表

列表.clear()
1

mylist.clear()
print(mylist)
1
2

g.统计元素出现了几次

列表.count(元素)
1

h.遍历列表

既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。将容器内的元素依次取出进行处理的行为，称之为:遍历、迭代。

1. while 循环

#列表while循环
def mylist_while():
    mylist = [1,2,3,4]
    index = 0
    while index < len(mylist):
        print(f"列表元素有：",mylist[index])
        index += 1

mylist_while()
1
2
3
4
5
6
7
8
9

2. for 循环

#列表for循环
def mylistfor():
    mylist = [1,2,3,4]
    for element in mylist:
        print(f"列表元素有：{element}")
mylistfor()
1
2
3
4
5
6

2.元组（tuple）

2.1定义格式

元组同列表一样，都是可以封装多个、不同类型的元素在内。但最大的不同点在于:
元组一旦定义完成﹐就不可修改
元组使用小括号 ( )，列表使用方括号 [ ]
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
>>> type(tup3)

1
2
3
4
5

2.2 元组相关操作

1. 创建空元组

tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型


>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组

1
2
3
4
5
6
7

2. 元组索引
   
   元组可以使用下标索引来访问元组中的值

3. 修改元组
   元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tup3 = tup1 + tup2
print (tup3)
1
2

4. 删除元组
   元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

del tup
print ("删除后的元组 tup : ")
print (tup)
1
2
3

以上实例元组被删除后，输出变量会有异常信息

5. 元组运算符

('Hi!',) * 4	
('Hi!', 'Hi!', 'Hi!', 'Hi!')	 #复制
1
2

3 in (1, 2, 3)	
True	 #元素是否存在
1
2

for x in (1, 2, 3): 
    print (x, end=" ")	
    1 2 3	#迭代
1
2
3

6. 元组内置函数
   6.1 len(tuple)
   计算元组元素个数
   6.2 max(tuple)
   返回元组中元素最大值
   6.3 min(tuple)
   返回元组中元素最小值
   6.4 tuple(iterable)
   将可迭代系列转换为元组

>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu')
1
2
3
4

2.3 元组的遍历

1. while

tup = (1, 2, 3, 4)
index = 0
while index < len(tup):
    index += 1
    print(index)
1
2
3
4
5

2. for

tup = (1, 2, 3, 4)
for element in tup:
    print(element)
1
2
3

3.字符串

字符串是字符的容器，一个字符串可以存放任意数量的字符。

3.1字符串的操作

1. 字符串的替换
   语法:字符串.replace(字符串1，字符串2)
   功能:将字符串内的全部:字符串1,替换为字符串2
   注意:不是修改字符串本身，而是得到了一个新字符串

4.数据容器的切片

序列是指:内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。

切片：从一个序列中取出一个子序列

语法:序列[起始下标:结束下标:步长]
1

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列:·起始下标表示从何处开始，可以留空，留空视作从头开始
·结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾·步长表示，依次取元素的间隔

• 步长1表示，一个个取元素（默认为1 可以不写）
• 步长2表示，每次跳过1个元素取·步长N表示，每次跳过N-1个元素取
• 步长为负数表示，倒序执行（注意，起始下标和结束下标也要反向标记)

mytuple = (1,2,3,4,5,6)
print(mytuple[:])#起始和结尾可以不写省略
1
2

对str进行切片,从头开始，到最后结束，步长-1

str1="123456"
print(str1[::-1])
1
2

结果：
654321

5.集合

定义：set = {}
无序的不支持索引访问,元素去重
添加元素：

set.add(" ")
1

移除元素：

set.remove( )
1

随机取出元素：

set.pop( )
1

清空集合：

set.clear( )
1

2个集合合并成一个（去重）

set.union( )
1

统计集合元素

len(set)
1

for循环遍历（不可下标索引，所以不能用while）

for element in set:
1

6.字典（映射)

key和value可以为任意数据类型（key不可为字典）
语法：

dict =  {key: value,key : value}
1

空字典：

dict( )
1

字典不允许重复key，不可下标索引

从字典中基于key获取value

dict["key"]
1

新增（更新）元素

字典[key] = value
1

删除元素

字典pop[key] = value
1

清除元素

dict.clear()
1

获取全部的key

dict.keys()
1

遍历字典

for key in keys:
for key in dict:
1
2

计算元素数量：

len(dict)
1

workers = {"wlh":{
               "department":"tech",
               "wage":3000,
               "rank":1},
    "zjl":{
        "department":"market",
        "wage":5000,
        "rank":2
    },
    "ljj":{
        "department":"market",
        "wage":7000,
        "rank":3
    }}
for key in workers:
    if workers[key]["rank"] == 1:
        workers1 = workers[key]
        workers1["wage"] = workers1["wage"] + 1000
        workers[key] = workers1
print(workers)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20