第一个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. 字面量
- 含义
在代码中，被写下来的的固定的值，称之为字面量 - 常见数据类型
2. 注释
# 单行注释
"""
多行注释
"""
3.变量
-
变量的含义: 在程序运行时，能储存计算结果或能表示值的抽象概念。简单的说，变量就是在程序运行时，记录数据用的
-
定义格式：
-
特征
变量值可以改变 -
练习
money = 50
print("钱包：",money)
icecream = 10
print("买冰淇淋：",icecream)
cola = 10
print("买可乐：",cola)
money = money - icecream - cola
print("钱包：",money)
4.数据类型
- type()语句
print(type(666))
print(type("666"))
print(type(3.3))
- 变量有类型吗?
我们通过type(变量)可以输出类型，这是查看变量的类型还是数据的类型?
查看的是:变量存储的数据的类型。
因为，变量无类型，但是它存储的数据有。
5. 数据转换
数据类型转换，将会是以后经常使用的功能。
如:
-
从文件中读取的数字，默认是字符串，我们需要转换成数字类型
-
input()语句，默认结果是字符串，若需要数字也需要转换
-
将数字转换成字符串用以写出到外部系统
int(x)
将x转换为一个整数
float(x)
将x转换为一个浮点数
str(x)
将对象×转换为字符串
6. 标识符
命名规则：
- 内容限定（不能数字开头）
标识符命名中，只允许出现:
英文
中文
数字
下划线（_)
这四类元素。 - 大小写敏感
- 不可使用关键字
7. 运算符
- 算术运算符
print(1+1)
print(2-1)
print(3*3)
print(3/3)
print(11//2)
print(9%2)
print(2**3)
结果：
2
1
9
1.0
5
1
8
- 赋值运算符
3.复合赋值运算符
8.字符串的扩展
8.1字符串的定义形式
字符串在Python中有多种定义形式:
1.单引号定义法: name ='666'
2.双引号定义法: name ="666"(最常用)
3.三引号定义法:name = """666"""
三引号定义法，和多行注释的写法一样，同样支持换行操作。使用变量接收它，它就是字符串
不使用变量接收它，就可以作为多行注释使用。
字符串的引号嵌套
思考:如果我想要定义的字符串本身，是包含:单引号、双引号自身呢?如何写?
·单引号定义法，可以内含双引号
·双引号定义法，可以内含单引号
·可以使用转移字符\ 来将引号解除效用，变成普通字符串
8.2 字符串的拼接
+号拼接
不过一般，单纯的2个字符串字面量进行拼接显得很呆，一般，字面量和变量或变量和变量之间会使用拼接
pinjie="sweetie"
print(pinjie+"yyds")
8.3字符串格式化
8.3.1 字符串格式化
语法：
%占位符"%变量
tips：多个变量占位
变量要用括号括起来并按照占位的顺序填入
age=21
personarity="nice"
she="她的年纪是%s,她性格:%s" %(age,personarity)
print(she)
age=21
personarity="nice"
she="她的年纪是%d,她性格:%s" %(age,personarity)
print(she)
8.3.2 格式化方式2
f"内容{变量}"
age=21
personarity="nice"
print(f"她的年纪是{age},她性格:{personarity}")
这种方式:
·不理会类型
·不做精度控制
适合对精度没有要求的时候快速使用
8.3.5对表达式进行格式化
表达式:一条具有明确执行结果的代码语句
f"(表达式}"
"%s%d\%f" %(表达式、表达式、表达式)
9. input语句
- input()语句的功能是，获取键盘输入的数据
- 可以使用: input(提示信息)，用以在使用者输入内容之前显示提示信息。
- 要注意，无论键盘输入什么类型的数据，获取到的数据永远都是字符串类型
print("who are you")
identity=input()
print("i know it,you are:%s" %identity)
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)}")
比较运算符的使用
== , !=, >, <,>=,<=
num1=10
num2=15
print(f"10!=15 result:{num1!=num2}")
str1="qwer"
str2="asdf"
print(f"str1=str2 result:{str1==str2}")
2.if语句的基本格式
-
if语句的基本格式
if要判断的条件:
条件成立时﹐要做的事情 -
if语句的注意事项:
判断条件的结果一定要是布尔类型
不要忘记判断条件后的:冒号
归属于if语句的代码块，需在前方填充4个空格缩进
print("input your age")
age=int(input())
if age>=18:
print("adult!")
print("children!")
3. if else 语句
- if else 语句，其中·
if和其代码块，条件满足时执行
else搭配if的判断条件，当不满足的时候执行 - if else语句的注意事项:
else不需要判断条件，当if的条件不满足时，else执行.
else的代码块，同样要4个空格作为缩进
age=int(input("input your age:"))
if age>=18:
print("adult!")
else:
print("children!")
4. if elif else语句
- 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")
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")
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")
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")
python第四章：循环语句
1.while的基础语法
while循环的注意事项：
条件需提供布尔类型结果，True继续，False停止。
空格缩进不能忘
请规划好循环终止条件﹐否则将无限循环
i=0
while i<10:
print("sweetie yyds")
i=i+1
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")
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")
补充
在字符串中，有一个特殊符号:\t，效果等同于在键盘上按下: tab键,它可以让我们的多行字符串进行对齐。
print("hello world")
print("sweetie yyds")
print("hello\tworld")
print("sweetie\tyyds")
通过两层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 空内容即为换行
3.for循环
除了while循环语句外，Python同样提供了for循环语句。两者能完成的功能基本差不多，但仍有一些区别:
. while循环的循环条件是自定义的，自行控制循环条件
. for循环是一种”轮询”机制，是对一批内容进行”逐个处理”
- 语法：
for 临时变量 in 待处理数据集
循环满足条件时执行的代码
遍历字符串：
name = "qwer"
for i in name:
print(i)
- 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")
- range语句
range()函数语法:
range(start, stop[, step])
参数说明：
- 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)
4. continue 和 break
-
临时中断
continue关键字用于:中断本次循环，直接进入下一次循环
continue可以用于:for循环和while循环，效果一致
-
永久中断
break关键字用于:直接结束循环
break可以用于:for循环和while循环，效果一致
-
注意事项:
. 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
python第五章：函数
1.函数
- 函数是:
组织好的、可重复使用的、用来实现特定功能的代码段 - 使用函数的好处是:
·将功能封装在函数内，可供随时随地重复利用
·提高代码的复用性，减少重复代码，提高开发效率
自己定义一个统计字符串长度的函数
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)
2.函数的定义
def say_hi():
print("hi")
say_hi()
函数的调用:函数名(参数)
注意事项：
参数如不需要，可以省略
返回值如不需要，可以省略
函数必须先定义后使用
3.函数的参数
传入参数的功能是:在函数进行计算的时候，接受外部（调用时）提供的数据
定义一个加法函数add
def add(x,y):
z = x + y
print(f"{x}+{y}={z}")
add(2,3)
传入参数的数量是不受限制的。
可以不使用参数
也可以仅使用任意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)
None类型
思考:如果函数没有使用return语句返回数据，那么函数有返回值吗
实际上是:有的。
Python中有一个特殊的字面量:None，其类型是:<class ‘NoneType’>无返回值的函数，实际上就是返回了:None这个字面量
None表示:空的、无实际意义的意思
函数返回的None，就表示，这个函数没有返回什么有意义的内容。也就是返回了空的意思。
def sayhi():
print("hi")
result = sayhi()
print(f"无返回函数返回内容：{result}")
print(f"无返回函数返回内容：{type(result)}")
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返回值
通过多行注释的形式，对函数进行说明解释。
内容应写在函数体之前
在PyCharm编写代码时，可以通过鼠标悬停，查看调用函数的说明文档
6.函数的嵌套调用
- 所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数
def print1():
print("1")
def print2():
print("2")
print1()
print("3")
print1()
print2()
- 执行流程
函数A中执行到调用函数B的语句，会将函数B全部执行完成后，继续执行函数A的剩余内容
7.变量的作用域
变量作用域指的是变量的作用范围(变量在哪里可用，在哪里不可用)
主要分为两类:局部变量和全局变量
所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效
全局变量
num =100
def test():
print(num)
test()
print(num)
使用 global关键字可以在函数内部声明变量为全局变量
python第六章：python数据容器
1. 数据容器
-
为什么要学习数据容器？
多个变量存储及使用 -
Python中的数据容器:
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
-
数据容器的类型：列表（ list)、元组(tuple)、字符串( str)、集合（set)、字典( dict )
1.1列表
tips:列表可以存储多种变量，并且支持嵌套（列表套列表）
list1 = [[1,2,3],[4,"t",4.5]]
print(type(list1))
print(list1)
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.1.2列表的常用操作方法
a. index（嵌套列表不可用）
查找某元素的下标
功能:查找指定元素在列表的下标，如果找不到，报错ValueError
语法:
列表.index(元素)
index就是列表对象（变量)内置的方法（函数)
mylist = [1,4.3,'flag']
index = mylist.index('flag')
print(f"flag的索引为：{index}")
b.修改列表中的值
语法:
列表[下标]=值
可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行:重新赋值（修改)
mylist[2] = 2.1
print(mylist)
c.插入元素
语法:
列表.insert(下标,元素)
在指定的下标位置，插入指定的元素
mylist.insert(3,666)
print(mylist)
d.将指定元素加在列表尾部
- 追加元素方式1:
语法:
列表.append(元素)
将指定元素，追加到列表的尾部
- 追加元素方式2:
语法:
列表.extend(其它数据容器)，
将其它数据容器的内容取出，依次追加到列表尾部
mylist.extend([2,22,222])
print(mylist)
mylist1= [2,22,222]
mylist.extend(mylist1)
print(mylist)
e.删除元素
语法1:del 列表[下标]
语法2:列表.pop(下标)
mylist = [1,4.3,'flag']
del mylist[1]
mylist.pop(1)
print(mylist)
删除某元素在列表中的第一个匹配项
语法:
列表.remove(元素)
mylist = [1,4.3,'flag',1]
mylist.remove(1)
print(mylist)
f. 清空列表
列表.clear()
mylist.clear()
print(mylist)
g.统计元素出现了几次
列表.count(元素)
h.遍历列表
既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。将容器内的元素依次取出进行处理的行为，称之为:遍历、迭代。
- while 循环
#列表while循环
def mylist_while():
mylist = [1,2,3,4]
index = 0
while index < len(mylist):
print(f"列表元素有：",mylist[index])
index += 1
mylist_while()
- for 循环
#列表for循环
def mylistfor():
mylist = [1,2,3,4]
for element in mylist:
print(f"列表元素有：{element}")
mylistfor()
2.元组（tuple）
2.1定义格式
元组同列表一样，都是可以封装多个、不同类型的元素在内。但最大的不同点在于:
元组一旦定义完成﹐就不可修改
元组使用小括号 ( )，列表使用方括号 [ ]
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d" # 不需要括号也可以
>>> type(tup3)
<class 'tuple'>
2.2 元组相关操作
- 创建空元组
tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：
>>> tup1 = (50)
>>> type(tup1) # 不加逗号，类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号，类型为元组
<class 'tuple'>
-
元组索引
元组可以使用下标索引来访问元组中的值 -
修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
tup3 = tup1 + tup2
print (tup3)
- 删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
del tup
print ("删除后的元组 tup : ")
print (tup)
以上实例元组被删除后，输出变量会有异常信息
- 元组运算符
('Hi!',) * 4
('Hi!', 'Hi!', 'Hi!', 'Hi!') #复制
3 in (1, 2, 3)
True #元素是否存在
for x in (1, 2, 3):
print (x, end=" ")
1 2 3 #迭代
- 元组内置函数
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')
2.3 元组的遍历
- while
tup = (1, 2, 3, 4)
index = 0
while index < len(tup):
index += 1
print(index)
- for
tup = (1, 2, 3, 4)
for element in tup:
print(element)
3.字符串
字符串是字符的容器，一个字符串可以存放任意数量的字符。
3.1字符串的操作
- 字符串的替换
语法:字符串.replace(字符串1，字符串2)
功能:将字符串内的全部:字符串1,替换为字符串2
注意:不是修改字符串本身，而是得到了一个新字符串
4.数据容器的切片
序列是指:内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。
切片：从一个序列中取出一个子序列
语法:序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列:·起始下标表示从何处开始，可以留空，留空视作从头开始
·结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾·步长表示，依次取元素的间隔
- 步长1表示，一个个取元素（默认为1 可以不写）
- 步长2表示，每次跳过1个元素取·步长N表示，每次跳过N-1个元素取
- 步长为负数表示，倒序执行（注意，起始下标和结束下标也要反向标记)
mytuple = (1,2,3,4,5,6)
print(mytuple[:])#起始和结尾可以不写省略
对str进行切片,从头开始，到最后结束，步长-1
str1="123456"
print(str1[::-1])
结果：
654321
5.集合
定义：set = {}
无序的不支持索引访问,元素去重
添加元素：
set.add(" ")
移除元素：
set.remove( )
随机取出元素：
set.pop( )
清空集合：
set.clear( )
2个集合合并成一个（去重）
set.union( )
统计集合元素
len(set)
for循环遍历（不可下标索引，所以不能用while）
for element in set:
6.字典（映射)
key和value可以为任意数据类型（key不可为字典）
语法：
dict = {key: value,key : value}
空字典：
dict( )
字典不允许重复key，不可下标索引
从字典中基于key获取value
dict["key"]
新增（更新）元素
字典[key] = value
删除元素
字典pop[key] = value
清除元素
dict.clear()
获取全部的key
dict.keys()
遍历字典
for key in keys:
for key in dict:
计算元素数量：
len(dict)
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)
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
