本文参看自菜鸟教程: Python3 教程 | 菜鸟教程 (runoob.com)
为快速复习使用,其中忽略和没解释的地方,还请去上方链接查看
Python特点:
Python是一种动态解释型的编程语言。Python可以在Windows、UNIX、MAC等多种操作系统上使用,也可以在Java、.NET开发平台上使用。
Python使用C语言开发,但是Python不再有C语言中的指针等复杂的数据类型。
Python具有很强的面向对象特性,而且简化了面向对象的实现。它消除了保护类型、抽象类、接口等面向对象的元素。
Python代码块使用空格或制表符缩进的方式分隔代码。
Python仅有31个保留字,而且没有分号、begin、end等标记。
Python是强类型语言,变量创建后会对应一种数据类型,出现在统一表达式中的不同类型的变量需要做类型转换// 注意python 的缩进很容易造成错误 -- 注意缩进
Python 和 shell 的简便实现
Python 和 Shell 一样都属于是脚本语言,他们的执行和编写都十分简单:
Python :
vi hello.py 创建文件
输入
print("Hello")
执行命令
python3 hello.py
Shell
vi hello.sh
输入
echo hellochmod +x hello.sh // 赋予这个文件可执行的权限
./hello.sh 执行即可
--------------------------------------
Linux 不太关心文件的格式 , 就算 不是/没 .py 后缀名 直接调用 python3 hello.txt, 也一样能执行
更关心权限, 能用 python3 调动得确保文件是可执行的(为了严谨还是建议加上.py后缀名)
======================
假定您的Python解释器在/usr/bin目录中,使用以下命令执行脚本:
$ chmod +x test.py # 脚本文件添加可执行权限
$ ./test.py
test.py文件 如下
#!/usr/bin/python
print ("Hello, Python!")
which python 查看python安装位置
=============================
py 的中文 编码:
if py 中文输出出现:
File "test.py", line 2
SyntaxError: Non-ASCII character '\xe4' in file test.py on line 2, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details
在文件头添加: 指定编码格式为中文的UTF-8标准
# -*- coding: UTF-8 -*-
========================
判断的时候注意缩进:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名:test.py
if True:
print ("Answer")
print ("True")
else:
print ("Answer")
# 没有严格缩进,在执行时会报错
print ("False") // 这块 会导致报错
====================================
python 的字符串 “” '' 都可以
====================================
输入输出:
input("这里添加描述")
//注意 input 获得的数是字符串, 需要我们希望的类型需要强转
case1:字符串拼接
a = input("请输入一个加数,按下 enter 退出\n")
b = input("请输入一个加数,按下 enter 退出\n")
ret = a+b
print(ret)
case2: 数字相加 // 注意python 的强转和C 有区别 --- int(a)
a = input("请输入一个加数,按下 enter 退出\n")b = input("请输入一个加数,按下 enter 退出\n")
ret = int(a)+int(b)
print(ret)
===============================================
变量赋值
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建,都包括变量的标识,名称和数据这些信息。
每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
等号 = 用来给变量赋值。
等号 = 运算符左边是一个变量名,等号 = 运算符右边是存储在变量中的值。例如:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
print (counter)
print (miles)
print (name)
==================================
Python字符串
字符串或串(String)是由数字、字母、下划线组成的一串字符。
一般记为 :
#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = 'Hello World!'
print (str) # 输出完整字符串
print (str[0]) # 输出字符串中的第一个字符
print (str[2:5]) # 输出字符串中第三个至第六个之间的字符串
print (str[2:]) # 输出从第三个字符开始的字符串
print (str * 2) # 输出字符串两次
print (str + "TEST") # 输出连接的字符串
======================================
Python 运算符:
算术运算符
比较运算符
赋值运算符
位运算符
逻辑运算符
成员运算符
身份运算符
运算符优先级
字符串运算符
===========================
Python3 条件控制
Python 条件语句是通过一条或多条语句的执行结果(True 或者 False)来决定执行的代码块。
// 注意: 和C语言的区别 True False -- 首字母大写
单条件
#!/usr/bin/python3
var1 = 100
if var1:
print ("1 - if 表达式条件为 true")
print (var1)
var2 = 0
if var2:
print ("2 - if 表达式条件为 true")
print (var2)
print ("Good bye!")
-----------------------------------------------
多条件:
#!/usr/bin/python3
age = int(input("请输入你家狗狗的年龄: "))
print("")
if age <= 0:
print("你是在逗我吧!")
elif age == 1:
print("相当于 14 岁的人。")
elif age == 2:
print("相当于 22 岁的人。")
elif age > 2:
human = 22 + (age -2)*5
print("对应人类年龄: ", human)
### 退出提示
input("点击 enter 键退出")
-----------------------------------------
if 嵌套
# !/usr/bin/python3
num=int(input("输入一个数字:"))
if num%2==0:
if num%3==0:
print ("你输入的数字可以整除 2 和 3")
else:
print ("你输入的数字可以整除 2,但不能整除 3")
else:
if num%3==0:
print ("你输入的数字可以整除 3,但不能整除 2")
else:
print ("你输入的数字不能整除 2 和 3")
---------------------------------------------------
match...case
// 小声 哔哔, 不就是switch case 嘛
Python 3.10 增加了 match...case 的条件判断,不需要再使用一连串的 if-else 来判断了。
match 后的对象会依次与 case 后的内容进行匹配,如果匹配成功,则执行匹配到的表达式,否则直接跳过,_ 可以匹配一切。
def http_error(status):
match status:
case 400:
return "Bad request"
case 404:
return "Not found"
case 418:
return "I'm a teapot"
case _:
return "Something's wrong with the internet"mystatus=400
print(http_error(400))
================================
Python3 循环语句循环
语句: 注意无论是while 还是 for 后面都带 :
print 的连接;
比如:
case1:
count =100
print 'The count is:'. count
case2:
prin('当前水果: %s' % fruit) // fruit -- 可以是 字符串 or 字符
--------------------------------------------------------------
需要注意冒号和缩进。另外,在 Python 中没有 do..while 循环。
case1 :
#!/usr/bin/env python3
n = 100
sum = 0
counter = 1
while counter <= n:
sum = sum + counter
counter += 1
print("1 到 %d 之和为: %d" % (n,sum))
------------------------------
while 循环使用 else 语句
如果 while 后面的条件语句为 false 时,则执行 else 的语句块。
#!/usr/bin/python3
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")
----------------------------------------------------
Python for 循环实例:
#!/usr/bin/python3
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
print(site)word = 'runoob'
for letter in word:
print(letter)
--------------------------------------------------
整数范围值可以配合 range() 函数使用:
for x in range(6):
print(x)
else:
print("Finally finished!")
---------------------------------------
range() 函数
如果你需要遍历数字序列,可以使用内置 range() 函数。它会生成数列,例如:
>>>for i in range(5):
... print(i)
...
0
1
2
3
4
---------------
>>>for i in range(5,9) :
print(i)
5
6
7
8
>>>
--------------------------
>>>for i in range(0, 10, 3) :
print(i)
0
3
6
9
>>>
--------------------
>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
... print(i, a[i])
...
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>
==============================================
Python pass 语句
Python pass 是空语句,是为了保持程序结构的完整性。
pass 不做任何事情,一般用做占位语句。
==============================================
Python 字符串
字符串拼接: +
Python 字符串格式化
#!/usr/bin/python
print ("My name is %s and weight is %d kg!" % ('Zara', 21) )
==============================================
Python 列表(List) ------- []
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推。
Python有6个序列的内置类型,但最常见的是列表和元组。
序列都可以进行的操作包括索引,切片,加,乘,检查成员。
此外,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
case1:
#!/usr/bin/python
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]
print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])
case2:
#!/usr/bin/python
list1 = ['physics', 'chemistry', 1997, 2000]
print (list1)
del list1[2]
print ("After deleting value at index 2 : ")
print (list1)
==============================================
Python 元组 -------------- ()
Python 的元组与列表类似,不同之处在于元组的元素不能修改。
元组使用小括号,列表使用方括号。
元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。
case1 :#!/usr/bin/python
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
---------------------------------------
修改元组
元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,如下实例:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
===================================
Python 字典(Dictionary) -------- {}
字典是另一种可变容器模型,且可存储任意类型对象。
字典的每个键值 key:value 对用冒号 : 分割,每个键值对之间用逗号 , 分割,整个字典包括在花括号 {} 中
#!/usr/bin/python
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
字典的一个嵌套:
#!/usr/bin/python3
garbage_dict = {'Data': {'Elements': [{'Category': '干垃圾', 'CategoryScore':
0.8855999999999999, 'Rubbish': '', 'RubbishScore': 0.0}], 'Sensitive': False},
'RequestId': '1AB9E813-3781-5CA2-95A0-1EA334E80663'}#!/usr/bin/python3
garbage_dict = {'Data': {'Elements': [{'Category': '干垃圾', 'CategoryScore':0.8855999999999999, 'Rubbish'i: '', 'RubbishScore': 0.0}], 'Sensitive': False},
'RequestId': '1AB9E813-3781-5CA2-95A0-1EA334E80663'}print(garbage_dict)
case :#!/usr/bin/python3
garbage_dict = {'Data': {'Elements': [{'Category': '干垃圾', 'CategoryScore':0.8855999999999999, 'Rubbish': '', 'RubbishScore': 0.0}], 'Sensitive': False},
'RequestId': '1AB9E813-3781-5CA2-95A0-1EA334E80663'}# print(garbage_dict)
data = garbage_dict['Data']
# print(data)
element = data['Elements']
# print(element)category = element[0]['Category']
# print(category )categ2 = garbage_dict ['Data']['Elements'][0]['Category']
print(categ2)
// category = element[0]['Category'] -- Elements 是一个元素列表 ,虽然只有一个元素,这个元素是字典,
但是也是列表 要访问这个字典就要先拿到 element[0], 然后第二个[] 才指向字典的 键,来匹配
==============================
Python 日期和时间
Python 程序能用很多方式处理日期和时间,转换日期格式是一个常见的功能。
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜(历元)经过了多长时间来表示。
case : import time -- 需要包含 time 包
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import time
# 格式化成2016-03-20 11:45:39形式
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) )
# 格式化成Sat Mar 28 22:24:24 2016形式
print (time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) )
# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print (time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")) )
===================================================
Python 函数
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数,以下是简单的规则:
函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始,并且缩进。
return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
case1 :#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 定义函数
def printme( str ):
"打印任何传入的字符串"
print (str)
return
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")
----------------------
python 传不可变对象实例 -- 形参
#!/usr/bin/python
# -*- coding: UTF-8 -*-
def ChangeInt( a ):
a = 10
b = 2
ChangeInt(b)
print (b) # 结果是 2
----------------------
传可变对象实例 -- 实参 -- 传的是地址
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 可写函数说明
def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4])
print ("函数内取值: ", mylist)
return
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)
--------------------------------
参数
参数类型:
必备参数
关键字参数
默认参数
不定长参数
必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数,你必须传入一个参数,不然会出现语法错误:
关键字参数
关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。
默认参数
调用函数时,默认参数的值如果没有传入,则被认为是默认值。下例会打印默认的age,如果age没有被传入:
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述2种参数不同,声明时不会命名
--------------------------------------------------------------------------
匿名函数 -- 类似宏
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式,函数体比def简单很多。
lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
============================================
Python 模块
Python 模块(Module),是一个 Python 文件,以 .py 结尾,包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用,更易懂。
模块能定义函数,类和变量,模块里也能包含可执行的代码。
case1 :
support.py 模块:
def print_func( par ):
print ("Hello : ", par)
return
import 语句
模块的引入
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")-------------------------
case 1.2
from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 导入模块
from support import print_func
# 现在可以调用模块里包含的函数了
print_func("Runoob")
-----------------------------------------
from…import* 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的,只需使用如下声明:
-----------------------
dir()函数
dir() 函数一个排好序的字符串列表,内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块,变量和函数。如下一个简单的实例:
======================
搜索路径
当你导入一个模块,Python 解析器对模块位置的搜索顺序是:
1、当前目录
2、如果不在当前目录,Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3、如果都找不到,Python会察看默认路径。UNIX下,默认路径一般为/usr/local/lib/python/。
模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录,PYTHONPATH和由安装过程决定的默认目录
===================================
Python 文件I/O:
case:
#!/usr/bin/python3
# 打开文件
fo = open("runoob.txt", "r+")
print ("文件名: ", fo.name)str = "6:www.runoob.com"
# 在文件末尾写入一行
fo.seek(0, 2)
line = fo.write( str )# 读取文件所有内容
fo.seek(0,0)
for index in range(6):
line = next(fo)
print ("文件行号 %d - %s" % (index, line))# 关闭文件
fo.close()
--------------------------
#!/usr/bin/python3
# 打开文件
fo = open("runoob.txt", "r+")
print ("文件名为: ", fo.name)line = fo.read(10)
print ("读取的字符串: %s" % (line))# 关闭文件
fo.close()
===========================
while True:
try:
x = int(input("请输入一个数字: "))
break
except ValueError:
print("您输入的不是数字,请再次尝试输入!")
=============================================