Python学习 | 一个JAVA程序员两天的Python入门笔记

转载本文章请标明作者和出处
​

能阻止你成功的人，只有你自己

vlog

• • 
    
• 时间：2020年02月28日-2020年03月01日 ——————两个白天，一个通宵
• 学习方式：视频（黑马），博客，百度
• 完成内容：python基础语法
• 博客目的：总结归纳，当然要能帮助其他刚学习Python的童鞋，不胜荣幸
• 人物：一个心血来潮学习Python的JAVA程序员
  • 
    

文章目录

• • 
    
• ​​vlog​​
• ​​正文​​

• • 
    
• ​​入门基础​​
• ​​注释​​
• ​​算数运算符及优先级​​
• ​​程序执行原理​​
• ​​变量​​

• • 
    
• ​​概念和定义方式​​
• ​​变量的命名​​
• ​​变量的作用域​​
• ​​变量的输入和输出​​
• ​​数据类型​​

• • 
    
• ​​数值型​​
• ​​非数值型​​

• • 
    
• ​​列表​​
• ​​元组​​
• ​​列表与元组的互相转换​​
• ​​字典​​
• ​​Set​​
• ​​字符串​​
• ​​在Python中所有非数字型变量都支持的特点​​
  • 
    

• ​​完整的for循环​​
• ​​可变数据类型和不可变数据类型​​
  • 
    

• ​​局部变量和全局变量​​
  • 
    

• ​​逻辑语句​​
• ​​循环​​
• ​​函数​​
• ​​模块​​
• ​​明信篇管理代码​​
  • 
    

正文

入门基础

• • 
    
• Python之父：吉多，人生格言：人生苦短，我用Python
• Python是一门解释型语言
• 
  
  • • 
      
  • 解释型语言
    解释型语言是直接把脚本丢给解释器执行，解释器是跨平台的，所以开发者是不用考虑跨平台问题的；Java、Python都是解释型语言，解释型语言每条语句都是执行到了才翻译的，效率比较低，java在丢给虚拟机（解释器）之前还有一个编译的步骤，.class文件有点像中间语言的意思。
  • 编译型语言
    编译型语言，如C、C++，是直接把源文件编译成机器语言，直接丢给操作系统执行，但是如果是不同的操作系统，所需要的二进制文件是不一样的，所以编译型语言移植操作系统以后，是需要重新编译的。但是因为是直接执行整个机器语言的文件，所以效率会相对解释型语言来说比较快。
    • 
      
• 
  
• Python语言的设计哲学
• 
  
  • • 
      
  • 优雅、明确、简单，一版情况下，Python的代码量是Java的1/5
  • python是一门完全面向对象的语言，拥有十分强大的标准库和第三方库
    • 
      
• 
  
• 第一次写Python程序须知
• 
  
  • • 
      
  • Python程序其实就是一个特殊格式的文本文件
  • Python文件的拓展名通常是以.py结尾的
  • Python中不能将多行代码写到一行，一行代码只完成一件事情，一行代码写多行，如条件判断很长，使用“\”，Python会当做一行处理
  • Python中是用缩进来代替大括号的，所以不正确的缩进也会报错
  • Python2不支持中文，Python3支持
  • Python3是2008年发布的，并不向下兼容2.*版本;
    • 
      
• 
  
• 运行Python程序的方法
• 
  
  • • 
      
  • 使用解释器，python 文件名.py；解释器官方版本是C语言写的，还有其他用JAVA等语言写的解释器版本
  • python shell 交互式
  • ipython 带自动补全和缩进的shell；ipython需要安裝 pip install ipython
  • 集成开发环境，IDE （一般使用pycharm）
    • 
      
• 
  
  • 
    

注释

• Python的注释

• • 
    
• 单行注释

• • 
    
• 行首# 加空格加注释内容
• 代码后空两格加#加空一格加注释内容
  • 
    

• 多行注释

• 上下三个双引号或者三个单引号中间加注释

算数运算符及优先级

• 算数运算符

• • 
    
• + 加
• - 减
• * 乘 （字符串*一个数字会重复数字对应遍）
• / 除（9/2=4.5）
• // 整除 （9//2=4）
• % 取余（9%2=1）
• **（幂 2**3=8）
  • 
    

• 优先级

• • 
    
• 第一级别 **
• 第二级别 * / // %
• 第三级别 + -
• 高级别的先执行，同级别从左往右执行，括号可以改变执行的顺序
  • 
    

程序执行原理

计算机三大件

• • 
    
• CPU：中央处理器，干活的
• 内存：临时保存数据的，速度特地快，重启数据就没了
• 硬盘 ：永久性存储数据的，速度比较慢
  • 
    

执行原理
CPU会先把解释器加载到内存中（解释器python2.7的是3.5M），再把程序加载到内存，然后CPU根据解释器去翻译并运行python程序

变量

概念和定义方式

• • 
    
• 变量就是程序在内存中要保存数据而开辟的一小块内存空阿金
• 使用交互式方式的时候，查看变量的值，直接输入变量名即可，不需要使用print函数；如果通过解释器输出变量的内容的话，需要通过print函数
• 变量的定义： 变量名 = 值 （不需要声明类型，运行的时候解释器会根据我们数据的内容自动推倒出保存的类型）
  • 
    

变量的命名

• • 
    
• 变量名由字母、下划线和数字组成
• 变量名开头不能是数字
• 变量名不能与关键字重复​​import keyword print(keyword.kwlist) ​​
• 上面三条不遵守解释器是会报错的
• 在Python中变量名如果由多个单词组成，我们一般多个单词都是小写然后用下划线隔开 qq_number
  • 
    

变量的作用域

Python除了def/class/lambda 外，其他如: if/elif/else/ try/except for/while并不能改变其作用域。定义在他们之内的变量，外部还是可以访问（与JAVA语法不同）

变量的输入和输出

• • 
    
• 输入 input函数，可以接受键盘录入的数据

• • 
    
• 变量名称 = input(“提示信息:”)
• input输入的内容都是字符串
• 类型的转换函数

• • 
    
• int(str) 将字符串转换成int
• float(str) 将字符串转换成float
• str(任意类型) 将任意类型转换为字符串
  • 
    

• 输出 格式化字符串

• • 
    
• %s代表字符串类型的数据
• %d输出整数，%06d代表输出整数的位数，不足用0补全，超出6位该是多少就是多少
• %f输出浮点数，%.02f代表输出小数点后两位
• %%输出百分号
• 语法

• • 
    
• print(“格式化字符串” % 变量1)
• print(“格式化字符串” % (变量1,变量2,变量3)) 后面的其实就是一个元组
  • 
    

数据类型

• • 
    
• 使用type()函数可以查看一个变量的数据类型
• 数值型的变量是直接可以进行算数运算符的计算的，包括bool型

• • 
    
• True会当做1
• False会被当做0
  • 
    

数值型

• • 
    
• 整型int ，在Python2.*中是区分int和long型的，在Python3中long型就被取代了，只有int类型
• 浮点型 float
• 布尔型 bool

• • 
    
• 真 True （非0即True）
• 假 False 0
• 参与算数运算的时候，True会被当做1，False会被当做0
  • 
    

• 复数型complex 主要用于科学计算（暂未了解）
  • 
    

非数值型

列表

• • 
    
• 列表是Python中使用最频繁的数据类型
• 列表用[]定义，数据之间是用，（逗号）隔开
• 列表用[]定义，数据之间是用，隔开
• list = [“zhangsan”,“lisi”,“wangwu”]
  list = [] 定义一个空列表
• list[索引值] 获取元素（切片的一种）
• 方法
• 
  
  • • 
      
  • 增加
  • 
    
    • • 
        
    • list.insert(索引,数据) 在指定的位置插入数据
    • list.append(数据) 在末尾添加数据
    • 列表.extend(列表2) 将列表2的数据追加到列表
      列表 += 列表2 和上面的作用相等
      • 
        
  • 
    
  • 修改
  • 
    
    • 列表[索引] = 数据 修改指定索引下的数据
  • 
    
  • 删除
  • 
    
    • • 
        
    • del 列表[索引] 删除指定索引的数据（本质上是将一个变量从内存中删除，不建议使用）
    • 列表.remove[数据] 删除列表中第一个出现的数据
    • 列表.pop() 删除末尾的数据
    • 列表.pop(索引) 删除指定索引的数据
    • 列表.clear() 清空列表
      • 
        
  • 
    
  • 统计
  • 
    
    • • 
        
    • len(列表) 列表的长度
    • 列表.count(元素) 统计列表中元素出现的个数
    • 列表.index(元素) 知道元素内容，确定索引
      如果列表中没有这个元素就会报错
      • 
        
  • 
    
  • 排序
  • 
    
    • • 
        
    • 列表.sort() 排序、升序
    • 列表.sort()、sort(reverse=True) 排序、降序
    • 列表.reverse() 反转列表
      • 
        
  • 
    
    • 
      
  • 
    

循环遍历

for 变量名 in 列表：
    循环内部对列表元素的操作

元组

元组与列表类似，但是元组的元素不能修改

元组用()定义，中间的元素用,逗号隔开

• • 
    
• 空元组 empty_tuple = ()
• 只有一个元素的元组 single_tuple = (元素,)
  只有一个元素，元素后面需要加一个逗号，要不直接就定义的是元素的类型的变量，而不是元组
  （1）是定义了一个int型的1（1,）才是定义了一个元组
  • 
    

元组中通常可以保存不同类型的数据

统计方法

• • 
    
• len(元组) 元组的长度
• 元组.count(元素) 统计元组中元素出现的个数
• 元组.index(元素) 知道元素内容，确定索引
  如果元组中没有这个元素就会报错
  • 
    

循环遍历

for 变量名 in 元组：
    循环内部对元组元素的操作

在实际开发中，除非能确定元组每个元素的类型，否则不会遍历元组，因为元组保存的元素的数据类型是不同的

元组的应用

• • 
    
• 当做函数的参数和返回值，可以接受多个参数和返回多个参数
• 格式化字符串后面的()其实就是一个元组
• 让列表不被其他人修改，保护列表中数据安全
  • 
    

列表与元组的互相转换

• • 
    
• list(元组) 元组转列表
• tuple(列表) 列表转元组
  • 
    

字典

• • 
    
• 字典是除了列表以外最灵活的数据类型，dictionary是无序的对象集合，使用{}来定义
• 字典使用键值对存储数据，键值对使用逗号进行分隔；
  键和值用:来分隔;
  键必须是唯一的；
  值可以是任何数据类型，但是键只能是元组、字符串或者数字（因为键只能是不可变数据类型，列表和字典是可变型）
• 定义
• 
  
  • • 
      
  • xiaoming = {“name”:“小明”,“age”:18}
  • xiaoming = {} 定义一个空字典
    • 
      
• 
  
• 函数
• 
  
  • • 
      
  • len(字典) 获取字典的键值对数量
  • 字典.keys() 所有key 的列表
  • 字典.values() 所有的值列表
  • 字典.items() 所有的(key,value)元组列表
    • 
      
• 
  
• 操作
• 
  
  • • 
      
  • 取值，字典[key值]，如果不存在key会报错
  • 增加/修改，字典[key] = value 向字段中新增键值对，如果key不存在是新增，存在就是修改
  • 删除，字典.pop(key) 如果key不存在的话会报错
  • 合并字典，字典1.update(字典2) 将字典2合并到字典1，如果字典2有字典1的键，会将其键值对覆盖
  • 清空字典，字典.clear() 将字典的所有键值对清空
  • 遍历字典

for key in 字典:
print("key=%s,value=%s" % (key,字典[key]))

Set

• • 
    
• set里面存储单个值，且是无序的，不重复的，存入相同的元素会自动去重
  
• 定义一个空set：set_1 = set()，因为{}是用来定义空字典的
  
• set有值定义
  ​​set_1 = { "name", "age" } ​​
• set 转列表和元组：list(set)、tuple(set)
  
• 列表和元组转set：set(列表或元组)
  
• set的遍历，和元组、列表的遍历方式一样
  ​​for 元素 in set: 遍历的操作 ​​
• set的运算符操作
  ​​print(set_1 | set_2) # set1和set2的并集 print(set_1 & set_2) # set1和set2的交集 print(set_1 - set_2) # set1和set2的差集(set1比set2多的部分) print(set_1 ^ set_2) # set1和set2中不公共存在的元素 ​​
  • 
    

字符串

一对单引号或者一对双引号引起来的一串字符叫做字符串

获取字符串里面的字符，可以使用字符串[索引]；
也可以使用for循环遍历

for char in 字符串:
    print(char)

方法

len(字符串) 获取这个字符串的长度

字符串.count(字符串1) 获取字符串中子字符串1出出现的次数（如果不存在不会报错）

字符串.index(字符串1)获得小字符串1第一次出现的索引
（如果不存在会报错）

判断|查找|替换类型的方法

• • 
    
• string.isspace() 如果string里面只包含制表符或者空格,返回True，空字符串返回False
• 字符串.startwith(字符串) 判断是否以指定的字符串开始
• 字符串.endwith(字符串) 判断是否以指定的字符串结束
• 字符串.find(字符串) 查找包含的字符串，存在的话返回开始的索引，不存在的话返回-1，index方法会操作，这个不会
• 字符串.replace(旧字符串,新字符串) 替换字符串里面的子字符串，会返回一个新的字符串，原有的字符串不会被修改（str是不可变类型的变量）
  • 
    

文本对齐

• • 
    
• string.ljust(width) 返回一个元字符串左对齐，并且使用空格填充至长度width的新字符串
• string.rjust(width) 返回一个元字符串左对齐，并且使用空格填充至长度width的新字符串
• string.center(width) 返回一个元字符串中间对齐，并且使用空格填充至长度width的新字符串
  • 
    

去除空白字符

• • 
    
• string.lstrip() 截掉左边的空白字符
• string.rstrip() 截掉右边的空白字符
• string.strip() 截掉两边的空白字符
  • 
    

拆分和合并

• • 
    
• string.split() 把大的字符串拆分成一个字符串列表
• string.join(序列) 以string为分隔符，将调用方法的字符串当做分隔符，把序列（列表、元组、字典）拼接成一个字符串
  • 
    

• 拼接方式
• 
  
  • • 
      
  • 两个字符串使用+号进行拼接
  • 一个字符串乘以一个整数可以把这个字符串重复整数次
  • 除此以外，字符串是不能和整数型有任何操作，比如字符串+10就会报错
    • 
      
• 
  

在Python中所有非数字型变量都支持的特点

• • 
    
• 都是一个序列，也可以理解为容器
• 取值 []
• 遍历 for in
• 计算长度len()、最大值max()、最小值min()、删除del()
• 连接+和重复*（字典没有*）
• 元素 in 序列 判断元素是否在序列中，字典只针对key
• 元素 not in 序列 判断元素是否不再序列中，字典只针对key
• 切片
• 
  
  • • 
      
  • 
    

切片的方法适用于字符串、列表和元组（字典使用的hash是没有顺序的）

字符串[开始索引:结束索引:步长]
结果不包含结束索引的内容；
步长指的是切完第一刀，隔几个再切第二个；
倒序索引-1指的是倒数第一个索引，不包含最后一个，要包含最后一个，结束索引不指定即可；

​​简书上讲的比较好的博客​​

习题

# 字符串的切片  （开始索引：结束索引：步长）
str_num = "0123456789"

# 截取2-5的字符串
print(str_num[2:6])
# 截取2到结束的字符串
print(str_num[2:])
# 截取开始到5的字符串
print(str_num[:6])
# 截取完整的字符串
print(str_num[:])
# 每隔一个截取的字符串
print(str_num[::2])
# 截取开始到倒数第二个字符串
print(str_num[:-1])
# 截取最后两个字符
print(str_num[-2:])
# 字符串倒序
print(str_num[::-1])

• Python的索引方式
  

查看在内存中的地址 id()

完整的for循环

for 变量 in 集合:
    循环代码
else:
    如果没有通过break跳出循环,循环结束之后会执行的代码

有continue语句也会执行else，只有有break不会执行

可变数据类型和不可变数据类型

• • 
    
• 不可变数据类型，内存中的数据不允许被修改（int、float、bool、complex、元组、字符串）
• 可变数据类型，内存中的数据可以修改（字典和列表）
• 字典的键只可以是不可变数据类型
  • 
    

局部变量和全局变量

• • 
    
• 局部变量是函数内部定义的变量，只能在函数的内部使用；
  全局变量是在函数外部定义的变量（没有定义在某一个函数内），所有函数内部都可以使用这个变量
• 局部变量在函数执行结束之后会被系统回收，局部变量可以重名
• 在python中是不允许直接修改全局变量的值的，如果修改，会默认定义了一个与全局变量名称一样的局部变量，如果确实希望对全局变量进行修改，可以声明一下global 变量名，然后在操作变量就是操作的全局变量
• 如果我们希望在代码中使用全局变量我们一般把全局变量定义到文件的最上方
• 全局变量的命名一版前面加g_或者gl_
• 编写代码的顺序
  
  • 
    

逻辑语句

• • 
    
• if elif else语句的语法

if 要判断的条件:
    要输出的语句
elif 要判断的条件:
    要输出的语句
else:
    条件不成立的时候，要执行的代码

• • 
    
• == 等于
• != 不等于 在Python2中不等于还可以使用<>来表示，在Python3中被取消了
• <= 小于等于
• >= 大于等于
• < 小于
• 大于 >
  • 
    

• • 
    
• and 与，两边都成立才是True
  条件1 and 条件2
• or 或，两边只要有一个满足就成立
  条件1 or 条件2
• not 非，对一个条件进行取反
  not 条件1
  • 
    

生成一个0到2的随机数

import random
computer = random.randint(0, 2)

循环

程序的三大流程

• • 
    
• 顺序执行，从上到下
• 分支，根据条件判断，让程序走特定的分支
• 循环，让特定的代码重复执行
  • 
    

语法

初始执行条件，通常是计数器
while 条件:
    条件满足的时候,需要做的事
    计数器的值的变动

死循环

• 程序员在循环内部忘记修改循环判断条件，导致程序循环执行，无法终止

赋值运算符

• • 
    
• = 、+=、-=、*=、/=、//=、%=、**=
• break 跳出当前循环
• continue 结束本次循环，继续下次循环
• print函数
• 
  
  • • 
      
  • print函数默认会在末尾加上换行
  • 如果不希望在输出的内容末尾加上换行
    print(“要打印的内容”,end="")
    • 
      
• 
  
  • 
    

函数

• • 
    
• 具有独立功能的小模块，在需要的时候调用
  
• 只有在函数定义之后再调用才可以，在一个文件中，调用在上，函数定义在下是会报错的
  
• 定义函数，def是定义的意思
  ​​def 函数名(): 函数封装的代码 .... ​​
• 函数的命名规则和变量的命名规则是相同的
  
• 注释

• • 
    
• 函数的注释应该定义在函数下方，连续使用三个引号
• 在函数调用的地方，使用ctrl+Q快捷键，可以看到定义的注释
  • 
    

• 参数

• • 
    
• 定义
  ​​ def 函数名(num1,num2): 函数封装的代码 .... ​​
• 形参是在函数小括号内部定义的参数，在函数内部可以当真正的参数使用
  
• 实参是调用函数的时候传递的参数
  
• 缺省参数

• • 
    
• 定义函数的时候，可以给某个参数指定一个默认值，如果没有传这个参数，这个参数默认就使用默认值
• 在参数后面使用赋值语句，就可以指定参数的缺省值；​​def print_info(name,gender=True): 函数体... ​​
• 缺省参数必须在整个参数列表的末尾，可以末尾有多个缺省参数，调用有多个缺省参数的函数的时候需要指定参数的名称list.sort(reverse=True)
• 多值参数

• • 
    
• 参数前增加一个号接收元组，一般参数起名为args
• 参数前增加两个*接收字典，一般参数起名为**kwargs
• *agrs和**kwargs同时存在，必须*args在前
• *agrs后面可以有缺省参数，**kwargs后面不可以有
• 使用方式​​def test(*args, **kwargs): print(args) print(kwargs) test(1, 2, 3, 4, name="YH", age=18) ​​
• 拆包

• • 
    
• 如果直接把一个元组变量和字典变量传递给多值参数，会都被元组接受，解决的方法就是拆包
  
• 案例
  ​​def test(*args, **kwargs): print(args) print(kwargs) list = [1, 2, 3] map = {"name": "1", "age": 2} test(list, map) 这么传的话*args会包括一个列表元素和一个字典元素长度为2而**kwargs会为空 ​​拆包之后就是正确的
  ​​def test(*args, **kwargs): print(args) print(kwargs) list = [1, 2, 3] map = {"name": "1", "age": 2} test(*list, **map) 拆包之后是正确的 ​​
  • 
    

• 返回值

• • 
    
• return 之后的代码都不会执行
• 调用函数的一方使用变量来接受返回结果
• 如果函数的返回类型是元组，那么小括号可以省略
• 交换两个变量的值（利用元组），a,b=b,a
• 可以使用多个变量来接收返回的元组 gl_1,gl_2 = fun1()
  • 
    

• python没有函数的重载，也就是你不能定义两个相同名称的参数，哪怕它们的参数列表不同
• 如果函数返回值是空，直接return，那么它接受返回值的变量is None
• 递归，自己调用自己
  • 
    

模块

• • 
    
• 模块就好比是一个工具包，要想使用这个工具包中的工具，就要导入这个模块；
  每一个以拓展名py结尾的Python源代码文件都是一个模块；
  在模块中定义的全局变量、函数都是模块能提供给外界直接使用的工具
• 模块名的命名规则和变量的命名规则一样
• 使用import导入的模块python解释器识别之后会编译成.pyc文件放到项目同级目录__pycache__下，这样导入的文件的内容就可以直接用了，不用一行一行解释
  • 
    

明信篇管理代码

• cards_main

"""
名片管理系统V1.0
"""
import cards_tools

while True:
    cards_tools.welcome_print()
    input_str = input("请输入您的操作: ")
    if input_str in ["1", "2", "3"]:
        if "1" == input_str:
            cards_tools.add_card()
        elif "3" == input_str:
            cards_tools.select_all()
        elif "2" == input_str:
            cards_tools.opera_card()
    elif input_str == "0":
        print("欢迎再次使用名片管理系统,再见~~~")
        break
    else:
        print("您输入的操作有误————请重新选择您的操作")

• cards_tools

card_list = []


def welcome_print():
    """
    名片系统欢迎提示词打印
    """
    print("*" * 50)
    print("欢迎来到名片管理系统V1.0")
    print("输入1: 新增名片")
    print("输入2: 管理名片")
    print("输入3: 查询所有名片")
    print("")
    print("输入0: 退出系统")
    print("*" * 50)


def add_card():
    """
    添加名片
    """
    name = input("请输入姓名")
    phone = input("请输入电话")
    age = input("请输入年龄")
    email = input("请输入email地址")
    card_list.append({
        "name": name,
        "phone": phone,
        "age": age,
        "email": email
    })


def del_card():
    """
    删除名片
    """
    name = input("请输入您要删除的名片人的名字: ")
    card = select_card(name)
    if card is None:
        return
    else:
        card_list.remove(select_card(name))


def opera_card():
    """
    对名片进行操作
    """
    print("输入1: 删除名片")
    print("输入2: 修改名片")
    opera = input("请输入您的对应操作")
    if opera in ["1", "2"]:
        if "1" == opera:
            del_card()
        elif "2" == opera:
            card = select_card(input("请输入您要查询的名片的姓名"))
            if card is None:
                return
            else:
                card["name"] = check(card["name"], input("请输入您要修改的名称"))
                card["phone"] = check(card["phone"], input("请输入您要修改的电话"))
                card["age"] = check(card["age"], input("请输入您要修改的年龄"))
                card["email"] = check(card["email"], input("请输入您要修改的邮件地址"))
                print("修改名片成功")

    else:
        print("您的输入有误")


def select_card(name):
    """
    根据名称查找名片
    """
    for card in card_list:
        if card["name"] == name:
            return card
    else:
        print("你所查找的<%s>不存在" % name)
    return


def select_all():
    """
    查询全部
    """
    if (n := len(card_list)) == 0:
        print("系统内暂无人员")
        return
    else:
        for temp in ["姓名", "电话", "姓名", "邮件"]:
            print(temp, end="\t")
        print("")
        print("=" * 50)
        for card in card_list:
            print("%s\t\t%s\t\t%s\t\t%s" % (card["name"], card["phone"], card["age"], card["email"]))


def check(str_opera, input_str):
    """
    校验是否输入
    """
    if len(input_str) == 0:
        return str_opera
    else:
        return input_str