Python基础

Python基础

• Author by liyihang
• Start:2018-12-06

第一章 Python简介

1.Python起源

• Python是吉多*范罗苏姆在1989年圣诞节，为了打发无聊而编写的一个解释程序
• python的意思：蟒蛇
• 解释型编程语言，无需编译
• 一般情况下，同样的功能，python的代码量是java的1/5
• 名言：life is short，you need python（人生苦短，我用python）
• 现有版本
  • python2.X（过去的版本），发布于2001年
  • python3.X（现在和未来主流版本，3.0发布于2008年）

2. Python的应用

• 云计算：云计算最火语言（云服务器）

• web开发：YouTube，豆瓣，知乎

• 人工智能：语音助手，AI音箱

• 自动化测试：我们使用的

3. Python的优点

• 易学
• 免费，开源
• 可移植性强（Windows，macOS，Linux）
• 丰富的库（拓展功能）

第二章 安装Python

1. 下载Python安装包

• 网址：www.python.org
• 注意：下载前要先确定系统位数
  

2. 安装

• 注意勾选添加python至系统环境变量（path）

• 修改安装路径（安装至C盘根目录，方便查找）

安装Python截图

3.第一个python程序

• win+r，输入cmd，打开命令行窗口
• 在命令行窗口中输入python，进入python交互模式
• 在交互模式中输入如下代码：

# 打印“你好，世界！” print('Hello World!')

Hello World!

第三章 输出与输入

1.输出

使用print函数在控制台输出指定内容

1.1 输出字符串和数字

# 输出字符串 print('Helloworld')  # 输出数字 print(123)

1.2 输出多个内容

需要同时输出多个内容时，使用逗号隔开

print('Helloworld',123)

1.3 输出不换行

print输出时默认是换行的，如果不想换行需要传入end参数

print('Helloworld',end='')

2.输入

python3中使用input函数从键盘获取数据，返回string类型

注意：在python3中，input将所有输入的数据都保存为字符串类型

username = input('请输入您的用户名：')

使用input输入数据，如果需要保持原类型，比如输入数字保存为原数字类型，需要进行转型操作

# 在input前加int（）将输入数据转成整数类型 username = int(input('请输入您的用户名：'))

第四章 安装Pycharm(编辑器)

1.下载Pycharm

• Pycharm官网地址：http://www.jetbrains.com/pycharm/

2.安装Pycharm

3.配置本地解释器

第五章 注释

1. 注释的作用

• 注释一般是用来说明代码的作用
• 纯给人看的，机器不会执行注释里的内容

2. 单行注释

• 单行注释，用#号表示
• 单行注释可以单独写一行，也可以写在需要注释的代码的右侧

# 这是一个单行注释 # 单行注释用一个#表示 # 可以在单独行写，也可以在某行代码后面写 print("hello word")

hello word

3. 多行注释（块注释）

• 多行注释，用一对三单引号或者双引号表示
• 多行注释通常用来为python文件、模块、类或者函数添加版权，功能等信息
• 多行注释可以用单行注释来实现

''' 这是多行注释 多行注释用三个单引号表示 多行注释中间会保持原格式 多行注释也叫文档注释(一般放在函数里) '''

'\n这是多行注释\n多行注释用三个单引号表示\n多行注释中间会保持原格式\n多行注释也叫文档注释(一般放在函数里)\n'

第六章 基础数据类型

• 查看数据类型用type（）函数，不能传两个数据类型

1. 整数（int）

游戏中使用数字记录分数，销售网站使用数字记录数量等

• 100，0，-100

a = 100             # 正整数 b = 0               # 0也是整数 c = -100            # 负整数 print(type(a)) print(type(b)) print(type(c))

<class 'int'> <class 'int'> <class 'int'>

2. 浮点数（float）

• 1.23，-1.0，0.0
• 注意：python中的除法结果会将整数转换成浮点数

a = 1.23            # 正浮点数 b = -1.0            # 负浮点数 c = 0.0             # 0.0也是浮点数 print(type(a)) print(type(b)) print(type(c))

<class 'float'> <class 'float'> <class 'float'>

注意：使用浮点数计算时，可能会出现小数位不确定的情况，暂时忽略即可，所有语言都有这个问题

print(0.1 + 0.2)  #0.30000000000000004

3. 字符串（str）

• ‘abc’
• ‘’（空字符也是字符串类型）

a = 'abc' b = ''              # 空字符串 c = '我爱中国！' print(type(a)) print(type(b)) print(type(c)) print(a) print(b) print(c)

<class 'str'> <class 'str'> <class 'str'> abc  我爱中国！

4. 布尔值（bool）

• True（真）
• False（假）

注意：布尔值可以转换为数值，True表示1，False表示0，但是不建议对布尔值进行计算

a = 1 b = 2 print(a<b) print(a>b)

True False

# 布尔值的计算 # True为1，Flase为0 a = 1 b = 2 c = a < b    # c为True d = a > b    # d为False  e = d - c    # e = 0 - -1 print(e)

5. 空值（None）

• 表示什么也没有
• 注意：不同于0和空字符串
• 用来占位置

a = None print(type(a))

<class 'NoneType'> 

第七章 变量

1. 变量的定义

• 变量是一个容器，里面可以存任意类型的数据

teacher = '刘老师'  # 定义了一个变量，变量名叫teacher，他里面储存了一个字符串刘老师

print(teacher + '简直帅毙了！')

如果又看见一次teacher=xxx，那么就不是定义变量了

而是变量的==重新赋值==

• 变量实质是储存在内存中的值，创建变量会在内存中开辟一个空间
• 变量是可以重复使用的一个量

2. 变量的命名规范

• 只能由数字、大小写字母、下划线组成
• 不能以数字开头
  • 4man，5for 是不可以的
  • man4，for5 是可以的
• 区分大小写
  • forMan 与 forman不是一个变量名称
• 不能使用系统关键字
  • class，from等 不可以
• 不推荐使用下划线开头，下划线开头具有特殊含义
• 推荐
  • 使用具有固定含义的英文单词缩写：srv=server，number=num
  • 驼峰命名法
    • 大驼峰：每个单词第一个字母大写（FirstName，LastName） 用在类名
    • 小驼峰：第一个字母小写，第二个单词开始每个单词首字母大小（firstName，lastName）变量或者函数名
    • 下划线：多个单词用下划线连接，单词全部小写（first_name, last_name）

什么是系统关键字？

• python一些具有特殊功能的标示符，这就是所谓的关键字
  • class, def, for...

怎么查看系统自带关键字

• 导入keyword包
• 使用keyword.list查看

# 查看关键字的方法 import keyword     # 导入关键字模块 print(keyword.kwlist)  # 打印出全部系统关键字

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

3. 变量的赋值

普通赋值

• 把赋值运算符右边的值给左边的变量

a = 100            #把整数100赋值给a print(a)

100

序列解包赋值

• 左边的变量与右边的值一一对应

a,b,c = 1,2,3 print(a, b, c)

1 2 3

链式赋值

• 一个值给多个变量

# 三个变量都放入同一个值 a = b = c = 1 print(a) print(b) print(c)

1 1 1

第八章 运算符

1. 算术运算符

加、减、乘、除

注意：

• 除法会将整数转为浮点数

• 除数不能为0，否则会报错

# 两个对象相加 a, b = 1, 2 print(a + b)  # 两个对象相减 a, b = 10, 5 print(a - b) # 使用负号得到负数 c = -5 print(c)  # 两个数相乘，乘号用*表示 a, b = 1, 2 c = a * b print(c)  # 两个数相除，除号使用/表示 # 注意：除法会将整数转为浮点数 # 注意：除数不能为0，否则会报错 a, b = 10, 5 print(a/b) 

取整除

• 两个数相除，返回商的整数部分

a, b = 10, 5 print(a//b)

2

取余

• 两个数相除，返回余数

注意：取余时，如果除数是负数，那么结果也是一个负数

a, b = 3, 2 print(a%b)

1

2. 赋值运算符

• “=”表示赋值运算符
• 把右边的结果给左边的变量

a = 2 c = a + 2 print(a) print(c)

2 4

加法赋值运算符

• c += a 等效于 c = c + a

a = 1 a += 1 print(a)

4. 逻辑运算符

• and：与，并且
  • 两个都为真，结果为真
  • 有一个为假，结果为假
• or：或
  • 有一个为真，结果为真
• not：非

a = True b = False c = True  d = a and b    # 有一个假，结果为假 print(d)  d = a and c    # 两个都为真，结果为真 print(d)  d = a or b    # 有一个为真，结果为真 print(d)      d = not a     # 非真即假 print(d)  d = not b     # 非假即真 print(d)

False True True False True

6.比较运算符

如果比较结果为真，则返回True；

如果比较结果为假，则返回False。

• 大于：>
• 小于：<
• 大于等于：>=
• 小于等于：<=
• 不等于：!=
• 等等于：==（两边值相等返回true，不相等返回false）

7. 运算符的优先级

• 永远记住，括号具有最高优先级

a, b, c = 1, 2, 3  d = a + (c - b)      # 把想要优先运算的部分用括号括起来 print(d)

2

第九章 字符串

1. 字符串的定义

• 字符串是python中的一种基础数据结构
• 通常是由引号包围的序列
  • 单引号
  • 双引号
  • 三单引号
  • 三双引号
• 特点

  • 有序

  • 不可变

love = 'i love you'    # 单引号 print(love)  love = "i love you"    #双引号 print(love)  # 三单引号 love = '''              i love you ''' print(love)  # 三双引号 love = """ i love you """ print(love)

i love you i love you               i love you

2. 格式化

• 把数据按照一定的格式打印或者填充

2.1 百分号格式化

利用百分号（%）

• %s：字符串
• %d：整数
• %f：浮点数

# 使用百分号格式化输出 name = '小明' age = 18 crash = 100.0  print('%s今年%d了，他有%f元现金。' %(name, age, crash))  # %f输出浮点数的时候可以指定精度，%.2f：保留两位 print('%s今年%d了，他有%.2f元现金。' %(name, age, crash))

小明今年18了，他有100.000000元现金。 小明今年18了，他有100.00元现金。

2.2 format格式化

# 使用format函数格式化输出 # 用大括号占位 s = "i love {}".format("china") print(s)  # 用大括号加编号占位，从0开始编号 y = "i love {0}, i am {1} years old, i love {0} very much!".format("china", 20) print(y)

i love china i love china, i am 20 years old, i love china very much!

3. 转义字符

转义字符：是指使用反斜杠\对一些特殊字符进行转义

常见的转义字符如下：

\n      换行符 \t      水平制表符

注意：在字符串前加上字母r（或R），那么该字符串就会原样输出，其中的转义字符将不会进行转义

# 打印出 i'm ‘OK’！ print("I\'m \'ok\'!" )  # 打印文件路径：c:\user print('c\\:user')  print(r"\t表示制表符") print('制表符前\t制表符后')  print(r'\n表示换行') print("第一行\n第二行")  print(r"这句话里的东西都不转义\\")  print("打印结束加end", end='hi')#end为空字符串时，可以起到不换行的作用

I'm 'ok'! c\:user \t表示制表符 制表符前    制表符后 \n表示换行 第一行 第二行 这句话里的东西都不转义\\ 打印结束加endhi

4. 字符串的索引和取值

索引

• <索引>就是编号
• 索引从0开始，不是从1开始
• 字符串实际上是字符的数组，所以也支持索引

name = 'HelloWorld' print(name[0])      # H print(name[1])      # e print(name[2])      # l

取值

• 取值是指对操作对象截取其中的一部分操作

• 取值的语法：[起始：结束：步长]

  • 注意：截取的区间为左闭右开，即从起始开始到结束前一位，不包括结束

• 使用方法：

  • [:]：从开始提取到结尾

  • [start:]：从起始下标提取到结尾

  • [:end]：从开头提取到结束下标，不包括结束下标

  • [start:end]：从起始下标截取到结束下标，不包括结束下标

    name = 'zhangsan'           # 从开头提取到结尾 print('从开头截取到结尾：{}'.format(name[:]))  name = 'zhangsan'           # 从起始下标提取到结尾 print('从起始下标1截取到结尾：{}'.format(name[1:]))  name = 'zhangsan'           # 从开头提取到结束下标5 print('从开头提取到结束下标5：{}'.format(name[:5]))  name = 'zhangsan'           # 从起始下标截取到结束下标3 print('从起始下标1截取到结束下标3：{}'.format(name[1:3]))  name = 'zhangsan'           # 从开头截取到结尾，步长为2 print('从开头截取到结尾，步长为2：{}'.format(name[::2]))

    从开头截取到结尾：zhangsan 从起始下标1截取到结尾：hangsan 从开头提取到结束下标5：zhang 从起始下标1截取到结束下标3：ha 从开头截取到结尾，步长为2：za

5. 字符串的常见方法

• 分割字符串：str.split()
• 将字符串中的某字符替换成其他字符
  • str.replace(原字符，新字符，替换次数)
  • 注意：可以通过次数来指定替换几次，适用于一个字符出现多次的情况

# 分割字符串 name = "a,b,c,d" print(name.split(","))   # 遇到逗号就分割，返回列表  # 将字符串转为大写 name = "abcd" print(name.upper())  # 将字符串转为小写 name = "ABCD" print(name.lower())  # 替换字符 name = "abcd" print(name.replace("a", "A"))  # 参数：被替换字符，替换后字符

['a', 'b', 'c', 'd'] ABCD abcd Abcd

6. 查找字符串

使用str.find()可以查找字符串中字符串出现的位置

返回字符串的==第一次出现的索引==，找不到则返回-1

格式：str.find(目标字符，开始位置，结束位置)

str = 'abbcdefg' print(str.find('b'))  # 查找a字符出现的位置，返回索引值 print(str.find('b',2))  # 从索引2的位置开始查找a字符，注意返回的索引值还是从0开始的

1 2

第十章 列表

1.列表的定义

• 列表是Python中的一种基础数据结构之一
• 列表用[]包围，元素用逗号隔开
• 元素可是任意数据类型
• 特点
  • 有序
  • 可变

虽然列表元素可以是任意数据类型，但是通常情况只放入一种类型的数据，这样可以提高程序的可读性

# 定义一个列表 a = [1, 2, 3] print(a)

[1, 2, 3]

list搭配range函数可以快速生成列表

# 快速生成一个偶数列表 l = list(range(2,11,2)) print(l)

2. 列表的循环嵌套取值

• 将取出的列表作为新的列表继续取值即可

a = [["a", "b"], "c", [1, 2]]  # 取出数字2 print(a[2][1])

2

3. 列表的常见方法

增加

# 添加值 a = [1, 2 ,3] a.append(4) print(a)

[1, 2, 3, 4]

 # 指定位置插入值 # 注意：insert插入值得效率没有append高 a = [1, 2 ,3] a.insert(0, 0)   # 索引，值 print(a)

[0, 1, 2, 3]

删除

 # 删除指定索引位置的值，不填索引删除最后一个 a = [1, 2 ,3] a.pop() print(a)  a = [1, 2 ,3] a.pop(0) print(a)

[1, 2] [2, 3]

# 删除指定值 a = [1, 2, 3] a.remove(3) print(a)

[1, 2]

修改

# 修改指定索引位置的值 a = [1, 2, 3, 4] a[0] = 2 print(a)

[2, 2, 3, 4]

反转

# 反转列表 a = [1, 2, 3, 4] a.reverse() print(a)

[4, 3, 2, 1]

统计

# 求列表最大值 a = [1, 2, 3, 4] print(max(a))

4

# 求列表最小值 a = [1, 2, 3, 4] print(min(a))

1

# 统计值在列表中出现的次数 a = [1, 2, 3, 4, 4, 4] print(a.count(4))

3

# 计算列表的长度 a = [1, 2, 3, 4] print(len(a))

4

# 列表从小到大排序 a = [2,4,1,3] a.sort()            # [1, 2, 3, 4]  # 列表从大到小排序 a = [2,4,1,3] a.sort(reverse=True)    # [4, 3, 2, 1]

第十一章 元祖

1.元祖的定义

• 元祖由（）包围，元素以逗号隔开
• 特点
  • 有序
  • 不可变
• 如果元祖只有一个元素，必须加逗号以示区分

# 当元祖只有一个元素时 a =(1)       # 不加逗号类型就不是元祖了 print(a) print(type(a))  b = (1,)     # 只有一个元素时，要加逗号区分 print(b) print(type(b))

1 <class 'int'> (1,) <class 'tuple'>

2. 元祖的常见方法

# 元祖转为列表 a = (1, 2, 3) b = list(a) print(b)

[1, 2, 3]

# 列表转元祖 a = [1, 2, 3] b = tuple(a) print(b)

(1, 2, 3)

# 求元祖的最大值 a = (1, 2, 3) print(max(a))

3

# 求元祖的最小值 a = (1, 2, 3) print(min(a))

1

# 求元祖的长度 a = (1, 2, 3) print(len(a))

3

第十二章 字典

1.字典的定义

• 字典用{}包围，元素以逗号隔开
• 字典中的数据必须以键值对的形式存在
• 键不可重复，值可以重复（若键重复，只会记住该键对应的最后一个值）
• 特点
  • 无序
  • 可变

# 定义一个字典 student = {"name":"zhangsan", "age":18} print(student) print(type(student))

{'name': 'zhangsan', 'age': 18} <class 'dict'>

2. 字典的常用方法

获取值

# 根据键获取值 student = {"name":"zhangsan", "age":18} print(student["name"])

zhangsan

修改值

# 根据键修改值，如果值不存在则添加 student = {"name":"zhangsan", "age":18} student["age"] = 19 print(student)  student["sex"] = "boy" print(student)

{'name': 'zhangsan', 'age': 19} {'name': 'zhangsan', 'age': 19, 'sex': 'boy'}

删除值

# 根据键删除键值对 student = {"name":"zhangsan", "age":18} student.pop("age") print(student)

{'name': 'zhangsan'}

# 随机删除一组键值对,以元祖形式返回被随机删除的键值对 stu1 = {"name":"zhangsan", "age":18, "sex":"boy"} stu2 = stu1.popitem() print("随机删除的是：") print(stu2) print("元祖中键值对少了一个：") print(stu1)

随机删除的是： ('sex', 'boy') 元祖中键值对少了一个： {'name': 'zhangsan', 'age': 18}

获取键

# 获取键 stu1 = {"name":"zhangsan", "age":18, "sex":"boy"} stu2 = stu1.keys() print(stu2)

dict_keys(['name', 'age', 'sex'])

获取值

# 获取值 stu1 = {"name":"zhangsan", "age":18, "sex":"boy"} stu2 = stu1.values() print(stu2)

dict_values(['zhangsan', 18, 'boy'])

获取键值对

# 获取键值对 stu1 = {"name":"zhangsan", "age":18, "sex":"boy"} stu2 = stu1.items() print(stu2)

dict_items([('name', 'zhangsan'), ('age', 18), ('sex', 'boy')])

第十三章 选择语句

• 语句格式：
  • if 条件：
    • 条件满足要做的事情1
    • 条件满足要做的事情2
    • ...
  • else：
    • 条件不满足时要做的事情1
    • 条件不满足时要做的事情2
    • ...

1. if-else

#  判断能否进入酒吧，18岁以上能进入，18岁以下禁止进入 age = int(input('请输入您的年龄：'))  if age>=18:      print('欢迎光临魅力四射~') else:      print('抱歉，您不能进入！')

2. elif

• 格式：
  • if xxx1:
    • 事情1
  • elif xxx2:
    • 事情2
  • elif xxx3:
    • 事情3

elif必须和if一起使用，否则会出错

# 判断成绩等级 # 优秀：90 <= 成绩 <= 100 # 良好：80 <= 成绩 < 90 # 中等：70 <= 成绩 < 80 # 一般：60 <= 成绩 < 70 # 不及格：0 <= 成绩 < 60 score = 95 if score>=90 and score<=100:     print("本次考试，成绩优秀！") elif score>=80 and score<90:     print("本次考试，成绩良好！") elif score>=70 and score<80:     print("本次考试，成绩中等！") elif score>=60 and score<70:     print("本次考试，成绩一般！") elif score>=0 and score<60:     print("本次考试，成绩不及格！")                                        

练习：季节判断

month = int(input('Month:')) if month in [3,4,5]:   print('春季') elif month in [6,7,8]:   print('夏季') elif month in [9,10,11]:   print('秋季') elif month in [12,1,2]:   print('冬季') else:   print('输入不合法')     month = int(input("请输入月份：")) if month >= 3 and month <= 5:     print("你输入的{}月份是春天".format(month)) elif month >= 6 and month <= 8:     print("你输入的{}月份是夏天".format(month)) elif month >= 9 and month <= 11:     print("你输入的{}月份是秋天".format(month)) elif month ==12 or month == 1 or month == 2 :     print("你输入的{}月份是冬天".format(month)) else:     print("月份输入不规范,请重新输入！")

3. if嵌套

• 格式

  • if 条件1:

    • 满足条件1 做的事情1
    • 满足条件1 做的事情2
    • ...(省略)...
    • if 条件2:
      • 满足条件2 做的事情1
      • 满足条件2 做的事情2
      • ...(省略)...

age = 17 food = 'no' if age>=18:     if food=='yes':         print('您带了酒水，不能进入')     else:         print('欢迎光临')     

4. if应用：猜拳游戏

# 猜拳游戏 import random  player = input("请输入：剪刀（0） 石头（1） 布（2）：")  player = int(player)      # 把输入的字符串转为整型  computer = random.randint(0,2)   # 随机生成一个在0-2之间的数  print("玩家输入：{}, 电脑输入：{}".format(player, computer))  # 测试  if (player == 0 and computer == 2) or (player == 1 and computer == 0) or (player == 2 and computer == 1):     print("获胜，哈哈，你太厉害了！") elif player == computer:     print("平局哦，要不要再来一局") else:     print("你输了，不要走，决战到天亮！")

第十四章 循环语句

1. 程序的三大执行

• 1.顺序执行
• 2.选择执行
  • if else
• 3.循环执行

2. while循环

• 格式
  • while 条件：
    • 满足条件做的事情
• 先判断再执行

打印1-10之间的数字

# 打印1-10之间的数字  # print(1) # print(2) # ...  # num = 1 # print(num)  # num = num + 1             找出需要重复执行的代码 # print(num)                在上面加上while  # num = num +1 # print(num)  i = 1 while i<=10:     print(i)     i = i + 1           # 这样的程序就叫循环执行

1 2 3 4 5 6 7 8 9 10

# 打印1-20之间的数 i = 1 while i<=20:     print(i)     i = i + 1    # 这句如果忘了写，就会一直打印1，陷入了一个死循环                  # 这句不写，语法没错，但是逻辑错了

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

3. while嵌套

• 格式
  • while 条件：
    • 条件满足时做的事情
    • ...
    • while 条件2：
      • 条件2满足时做的事情
      • ...

# 举例 ''' 给个任务：执行下面的动作10次 1.站起来 2.转5个圈 3.坐下 站起来坐下一共执行10次 转圈一共转了50个  用while来写： while 条件：     1.站起来     while 执行5次：         2.转1个圈     3.坐下 '''

'\n给个任务：执行下面的动作10次\n1.站起来\n2.转5个圈\n3.坐下\n站起来坐下一共执行10次\n转圈一共转了50个\n\n用while来写：\nwhile 条件：\n    1.站起来\n    while 执行5次：\n        2.转1个圈\n    3.坐下\n'

打印一个三角形

''' * ** *** **** *****  分析： 有五行，每行的东西不一样 既要控制行，又要控制列 做不到？ 先做一个简单的 先打印一个类似，再去修改，程序不是一次就写好的 先打印出一个矩形  '''

'\n*\n**\n***\n****\n*****\n\n分析：\n有五行，每行的东西不一样\n既要控制行，又要控制列\n做不到？\n先做一个简单的\n先打印一个类似，再去修改，程序不是一次就写好的\n先打印出一个矩形\n\n'

三角形无法一步到位打印出来，先打印矩形

# 打印矩形  # i = 1 # while i<=5: #     print("*****") #     i = i + 1  # i = 1 # while i<=5: #     j = 1 #     while j<=5: #         print("*")            # print打印默认换行了，怎么做到不换行？ #         j = j + 1 #     i = i + 1  # i = 1 # while i<=5: #     j = 1 #     while j<=5: #         print("*", end="")       # 加上end=‘’，打印不换行，但是*全在一行里了      #         j = j + 1 #     i = i + 1  i = 1 while i<=5:     j = 1     while j<=5:         print("*", end="")                    j = j + 1     print('')                      # 等到里边的while结束了，也就是打印了一行5个星号后，换行     i = i + 1

***** ***** ***** ***** *****

打印三角形

# 打印三角形 i = 1 while i<=5:     j = 1     while j<=i:             # 第一行一个，第二行两个...正好与i的值一致，并且i的值不受内循环影响         print("*", end="")                    j = j + 1     print('')                          i = i + 1

* ** *** **** *****

打印九九乘法表

# 打印九九乘法表 # i = 1 # while i<=9: #     j = 1 #     while j<=i:              #         print("X*Y=Z ", end="")           # 先把格式换上去 #         j = j + 1 #     print('')                      #     i = i + 1  i = 1 while i<=9:     j = 1     while j<=i:                      print("{}*{}={}\t".format(j,i,j*i), end="")      #加上一个\t对齐              j = j + 1     print('')                          i = i + 1

1*1=1       1*2=2   2*2=4    1*3=3   2*3=6   3*3=9    1*4=4   2*4=8   3*4=12  4*4=16   1*5=5   2*5=10  3*5=15  4*5=20  5*5=25   1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36   1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49   1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64   1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81  

4. for循环

• 格式
  • for 变量 in 序列：
    • 执行语句
• 作用：遍历对象

遍历字符串

# 遍历字符串 name = 'zhangsan'  for i in name:     print(i)

z h a n g s a n

遍历列表

name = ['zhangsan', 'lisi', 'wangwu']  for i in name:     print(i)

zhangsan lisi wangwu

遍历字典

# 遍历字典 stu = {'name':'zhangsan', 'age':18, 'sex':'man'}  # 遍历建和值 for key, value in stu.items():     print(key, ':', value)      print('-'*50)  # 遍历键 for key in stu.keys():     print('key=', key)  print('-'*50)  # 遍历值 for value in stu.values():     print('value=', value)

name : zhangsan age : 18 sex : man -------------------------------------------------- key= name key= age key= sex -------------------------------------------------- value= zhangsan value= 18 value= man

打印1-10之间的数字

for i in range(1,11):     print(i)

打印矩形

# 打印矩形 for i in range(1,9):     for j in range(1,9):         print("*", end="")     print("")

打印三角形

# 打印三角形 for i in range(1,9):     for j in range(1,i+1):         print("*", end="")     print("") for i in range(1,1):     print("开始打印rang1-1")     print(i)   #根本就没有值

* ** *** **** ***** ****** ******* ********

打印九九乘法表

# 打印九九乘法表 for i in range(1,10):     for j in range(1,i+1):         print("{}*{}={}".format(j,i,j*i), end="\t")     print("")    

1*1=1    1*2=2   2*2=4    1*3=3   2*3=6   3*3=9    1*4=4   2*4=8   3*4=12  4*4=16   1*5=5   2*5=10  3*5=15  4*5=20  5*5=25   1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36   1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49   1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64   1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81  

for if 嵌套

# for if 嵌套 # 打印列表里的所有姓名 # 如果是wangwu，就提示，他中奖了 name = ["zhangsan", "lisi", "wangwu"] for i in name:     print(i)     if i == "wangwu":         print("恭喜你中奖了！")     else:         print("不好意思，你没中奖！")     

zhangsan 不好意思，你没中奖！ lisi 不好意思，你没中奖！ wangwu 恭喜你中奖了！

==注意：if while 同样可以嵌套==

for循环练习题

1. 获取任意字符串的长度

s = 'name'  # 定义字符串 num = 0     # 定义长度为0 for i in s:     num += 1 # 每循环一次，num加1 print(num)

4

2. 给出任意一个字符串，打印出该字符串中的字母个数以及数字个数

str = input('请输入需要统计的字符串：') letter = 0 num = 0 for i in str:     if i in 'abcdefghijklmnopqrstuvwxyzABC':         letter += 1     elif i in '1234567890':         num += 1 print('这个字符串中有%d字母，%d个数字' %(letter, num))

3. 生成10个的斐波那契数列

# 从1开始，后面的数是前面两数之和 # 1  1  2  3  5 a, b = 0, 1 nums = [] for i in range(10):     nums.append(b)     a, b = b, a+b print(nums)

4. 求1-100之间的所有偶数和

sum = 0 for i in range(2,101,2):     sum += i print(sum)  sum2 = 0 for i in range(1,101):     if i%2==0:         sum2+=i print(sum2)

5. 计算2-3+4-5+6-7+8....100的值

num = 0 for i in range(2, 101):     if i%2==0:         num += i     else:         num -= i print(num)

第十五章 函数

1. 函数的定义

• 把具有独立功能的代码块组织成一个小模块

格式

def 函数名()：    函数代码

2. 函数的文档注释

• 函数的文档注释用一对三双引号包围，用来解释说明函数的作用

def GuShi():     '''这个函数用来打印一首古诗'''     print('百日依山尽')     print('黄河入海流')     print('欲穷千里目')     print('更上一层楼')      help(GuShi)

Help on function GuShi in module __main__:  GuShi()     这个函数用来打印一首古诗

3. 函数的参数

• 需求：定义一个函数，用来计算两个数之和

3.1 函数不带参数

• 不带参数只能固定计算函数里定义好的值

# 定义一个函数用来计算两个数之和 def add2num():     a = 1     b = 2     c = a + b     print(c)  add2num()

3

3.2 函数的形参和实参

• a,b叫形参（形式参数）：定义函数时的参数
• 1,2叫实参（实际参数）：实际调用时的参数
• 在调用函数时，用实参（1,2）替换形参（a,b），再去执行函数里面的代码

# 由于需要计算的值不固定，所以定义函数时携带两个参数 def add2num(a,b):      # a，b  形式参数     c = a + b     print(c)      add2num(1,2)           # 1,2  实际参数

3.3 函数参数的传递

3.3.1 位置传递

# 参数按照位置顺序传入 def add2num(a,b):      # a，b  形式参数     c = a + b     print(c)      add2num(1,2)           # 1,2  实际参数

3.3.2 关键字传递

# 指定形参的值，位置可以不按照形参顺序 def add2num(a,b):      # a，b  形式参数     c = a + b     print(c)      add2num(b=1,a=2)           # 1,2  实际参数

3.3.3 函数参数的默认值

• 函数参数在定义时可以给默认值，如果调用函数时没有传入实参，就使用参数的默认值
• 注意：拥有默认值的参数一般放在最后一个参数的位置，否则会报错

# 函数参数的默认值 def add2num(b, a=1):      # a，b  形式参数，注意：拥有默认值的参数a，应该放在参数的最后一个位置     c = a + b     print(c)      add2num(2)           # 1,2  实际参数

4. 函数的返回值

• 函数在执行完成后，一般情况下都会产生一个结果，使用return将这个结果返回给调用者，这就是返回值
• 函数中如果没有定义return，那么返回值为空（None）
• 函数只要执行到return就不会继续往下执行

# 用return返回结果给调用者 def add2num(a,b):     return a + b  c = add2num(1,2) print(c)

3

函数没有return，返回None

def add2num(a,b):     c = a + b  result = add2num(1,2) print(result)

None

只要执行了return，后续代码将不会执行

def add2num(a,b):     c = a + b          return c          c -= 1            result = add2num(1,2) print(result)

3

5. 局部变量与全局变量

• 全局变量：定义在函数外部的变量，在整个代码文件都生效

• 局部变量：定义在函数内部的变量，只在函数内部生效

  全局变量

a = 100          # 全局变量定义在函数外，作用于整个文件  def printNum():     print(a)     # 在函数内也可以调用该变量  printNum() 

100

局部变量

def printNum():     b = 100       # 局部变量定义在函数内部，只作用于函数内     print(b) printNum() print(b)          # 函数外部无法调用局部变量，错误提示为该变量未定义

100

global

• 使用global可以声明变量为全局变量

def printNum():     global b      # 使用global声明变量为全局变量     b = 100       # 局部变量定义在函数内部，只作用于函数内     print(b) printNum() print(b)          # 函数外部无法调用局部变量，错误提示为该变量未定义

100 100

6. 函数的跨文件使用

• 函数封装好以后，可以在其他文件导入并使用
• 导包的方式为：from 文件名 import 函数名

来源：https://www.cnblogs.com/onehang/p/11681471.html