这篇博客介绍了Python3的快速上手，包括环境搭建，编写第一个Python程序，学习字符串操作，理解运算符（算术和逻辑），以及掌握流程控制结构。此外，还详细讲解了四大数据容器——list、tuple、set和dict的使用。
环境搭建
首先，安装python环境：
本文主要学习python3，部分语法和python有差异；
第一个python
#!/usr/bin/python3
# 输入参数：./main.py arg1 arg2
import sys
# 导入包，类似头文件
# from somemodule import firstfunc, secondfunc, thirdfunc
# from somemodule import *
print("Hello, Python!")
# 第一个注释
'''
多行注释演示
'''
# 键盘输入
inputnum = int(input("按下 enter 键后退出:"))
print(inputnum)
# 多行命令（同shell）
x = 'hello python'
sys.stdout.write(x + '\n')
print('参数个数为:', len(sys.argv), '个参数。')
print('参数列表:', str(sys.argv))
if len(sys.argv) > 1:
print('手动列出命令行参数为:')
for i in sys.argv:
print(i)
print('共计', len(sys.argv), "个")
print('程序名为:', sys.argv[0])
print('\n python 路径为', sys.path)
字符串
#!/usr/bin/python3
import math
def main():
# 构造
MyStr = 'Runoob'
print(MyStr) # 输出字符串
# 切片
print(MyStr[0:-1]) # 输出第一个到倒数第二个的所有字符
print(MyStr[0]) # 输出字符串第一个字符
print(MyStr[2:5]) # 输出从第三个开始到第五个的字符
print(MyStr[5])
print(MyStr[2:]) # 输出从第三个开始后的所有字符
print(MyStr * 2) # 输出字符串两次
print(MyStr + '你好') # 连接字符串
print('------------------------------')
print('hello\nrunoob') # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
# 不换行
print(r"The same line output\n,", end="")
print(r"next line output")
# python中字符串不可改变
# 三引号来表示多行文本，这里不加r的话转义依旧有效
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
print(errHTML)
# print格式化输出
print("我叫 %s 今年 %d 岁!" % ('小明', 10))
addr = 0x45ae
print("point address is 0x%016x" % (addr)) # 按十六进制打印且不足补0
# f-string python3.6开始支持
name = 'Runoob'
print(f'My name is {name}') # 这里做了变量替换
print(f'1+2 = {1 + 2}') # 使用表达式
print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))
print('my name: {}'.format(name))
print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))
# show a table
print("a: {0:10d}".format(1))
print("b: {0:10d}".format(100))
print("x: {0:10d}".format(1000000))
# 在Python3中，所有的字符串都是Unicode字符串,使用16位来保存一个字符
# 翻转字符串(基于词)
def reverseWords(input):
print('test reverseWords')
# 通过空格将字符串分隔符，把各个单词分隔为列表
inputWords = input.split(" ")
# 翻转字符串
# 假设列表 list = [1,2,3,4],
# list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
# inputWords[-1::-1] 有三个参数
# 第一个参数 -1 表示最后一个元素
# 第二个参数为空，表示移动到列表末尾
# 第三个参数为步长，-1 表示逆向
inputWords = inputWords[-1::-1]
# 重新组合字符串
output = ' '.join(inputWords)
return output
def test_func():
# 打印：===============test_func================
str1 = 'test_func'
print(str1.center(40, '='))
# byte编解码测试
print('byte编解码测试')
str = "菜鸟教程"
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")
print(str)
print("UTF-8 编码：", str_utf8)
print("GBK 编码：", str_gbk)
print("UTF-8 解码：", str_utf8.decode('UTF-8', 'strict'))
print("GBK 解码：", str_gbk.decode('GBK', 'strict'))
# python3内存里都是unicode编码的，但比较消耗空间
# 当实际传递和保存数据时，通常先编码成utf-8，然后写盘和传输
# 接受和读取文件时，则需要从utf-8解码出来
# join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
print('test join()')
s1 = "-"
s2 = ""
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print(s1.join(seq))
print(s2.join(seq))
# lstrip() 截掉字符串左边的空格或指定字符
str = " this is string example....wow!!! "
print(str.lstrip())
str = "88888888this is string example....wow!!!8888888"
print(str.lstrip('8'))
print(str.lstrip('is')) # 只能是左边开始的
# split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串
cfg = "ceph/poolname/lunname"
print(cfg.split('/')) # 以空格为分隔符
print(cfg.split('/', 1)) # 分割 1 + 1 个串
print(cfg.split('name'))
# 类似main函数，条件判断：当前脚本为直接被执行的脚本时为True
if __name__ == "__main__":
input = 'I like runoob'
rw = reverseWords(input)
print(rw)
main()
test_func()
python的变量无需声明直接使用，而字符串变量在py中是不可改变的，如果需要修改，可以将已有字符串变量改变后重新赋值：
MyStr = 'Runoob'
MyStr = MyStr[:3] # 截取MyStr的前3个字符：'Run'
python中print函数本身无法做到C/C++中printf的功能，但字符串本身支持类似的格式化输出：
print("我叫 %s 今年 %d 岁!" % ('小明', 10)) # 2.7 & 3.x支持
# f-string python3.6开始支持
name = 'Runoob'
print(f'My name is {name}') # 这里做了变量替换
print(f'1+2 = {1 + 2}') # 使用表达式
print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))
print('my name: {}'.format(name))
#
运算（包含算术和逻辑）
#!/usr/bin/python3
import sys
# 算术运算
print(5 + 4) # 加法
print(4.3 - 2) # 减法,在混合计算时,Python会把整型转换成为浮点数
print(3 * 7) # 乘法
print(2 / 4) # 除法，得到一个浮点数
print(2 // 4) # 除法，得到一个整数
print(17 % 3) # 取余
print(2 ** 5) # 乘方
# Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
# 条件运算
if 10 > 8:
print('10 > 8')
if 10 == 10:
print('10 == 10')
if 10 != 8:
print('10 != 8')
# 逻辑预算
# and or not
# and比or not有更高的优先级
a = 10
b = 20
if a or b:
print("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
print("4 - 变量 a 和 b 都不为 true")
if not (a and b):
print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
print("5 - 变量 a 和 b 都为 true")
# 赋值运算
a = b = 2
b += a # 相当于b = b + a,因此b必须先定义
print(b)
# 还支持 -= *= /= %= **= //=
# 海象表达式：在表达式内部为变量赋值(需要3.8以上版本支持)
# a = '01234567891'
# 在这个示例中，赋值表达式可以避免调用 len() 两次:
# if (n := len(a)) > 10: # n被赋值后，还可以用n和10作比较，而正的赋值运算符不行
# print(f"List is too long ({n} elements, expected <= 10)")
# 位运算，和c++类似
# 支持： & | ^ ~ << >>
# 成员运算:测试实例中包含了一系列的成员，包括字符串，列表或元组
a = 10
b = 20
list = [1, 2, 3, 4, 5];
if (a in list):
print("1 - 变量 a 在给定的列表中 list 中")
else:
print("1 - 变量 a 不在给定的列表中 list 中")
if (b not in list):
print("2 - 变量 b 不在给定的列表中 list 中")
else:
print("2 - 变量 b 在给定的列表中 list 中")
# 身份运算，对应C语言就算看内存实例是不是相同
a = 20
b = 20
if (a is b):
print("1 - a 和 b 有相同的标识")
else:
print("1 - a 和 b 没有相同的标识")
if (id(a) == id(b)):
print("2 - a 和 b 有相同的标识")
else:
print("2 - a 和 b 没有相同的标识")
流程控制
#!/usr/bin/python3
# python的条件判断只有if，else使用"elif:"
# num=int(input("输入一个数字："))
num=78
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")
str='zxcvasdf'
if 'cv' in str:
print('cv in %s' % str)
# 循环支持for和while，还可以和else配合使用
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")
# for <variable> in <sequence>:
# <statements>
# else:
# <statements>
for i in range(5):
print(i, end='')
for i in range(1, 5):
print(i, end='')
# break和 continue 功能一致，不演示
数据容器（list、tuple、set、dict）
#!/usr/bin/python3
import sys
def list_demo():
print('\ntest list')
"""
列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）
列表是写在方括号 [] 之间、用逗号分隔开的元素列表
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表
"""
# 构造
list = ['abcd', 786, 2.23, 'runoob', 70.2]
tinylist = [123, 'runoob']
tinylist_null = []
print("list 截取:")
print(list) # 输出完整列表
print(list[0]) # 输出列表第一个元素
print(list[1:3]) # 从第二个开始输出到第三个元素
print(list[2:]) # 输出从第三个元素开始的所有元素
print(tinylist * 2) # 输出两次列表
print(list + tinylist) # 连接列表
print('list中的元素是可以改变的')
a = [1, 2, 3, 4, 5, 6]
print(a)
a[0] = 9
a[2:5] = [13, 14, 15]
a[2:5] = [] # 将对应的元素值设置为 []
print(a)
# 列表推导式
print('列表推导式')
vec = [2, 4, 6]
print([3*x for x in vec])
print([[x, x**2] for x in vec])
freshfruit = [' banana', ' loganberry ', 'passion fruit ']
print([weapon.strip() for weapon in freshfruit])
def tuple_demo():
print('\ntest tuple')
# 元组的元素不能修改,元组写在小括号 () 里,元素之间用逗号隔开
# 构造
test_tuple = ('abcd', 786, 2.23, 'runoob', 70.2)
tinytuple = (123, 'runoob')
print(test_tuple) # 输出完整元组
print(test_tuple[0]) # 输出元组的第一个元素
print(test_tuple[1:3]) # 输出从第二个元素开始到第三个元素
print(test_tuple[2:]) # 输出从第三个元素开始的所有元素
print(tinytuple * 2) # 输出两次元组
print(test_tuple + tinytuple) # 连接元组
# tuple[0] = 9 tuple is not allow modify
# 截取的方法和list string一致，这里不演示了
# 构造0或在1的元祖语法：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
def set_demo():
# 基本功能是进行成员关系测试和删除重复元素
print('\ntest set')
# 构造
student1 = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
# 插入
add_item = ('I', 'OK')
student1.update(add_item) # update 是通过seq类型，把每一项插入set中
print(student1)
student1.remove('I')
student1.remove('OK')
student1.add(add_item) # add 是直接把入参当作一个对象，而set要求是不可修改的类型，因此这里传tuple
print(student1)
student1.remove(add_item) # 允许移除tuple
student2 = set(('Tom', 'Jim', 'Mary', 'Mary', 'Jim')) # set中需要指定一个seq，可以是string,list,tuple等,set会负责去重
student_list = ['Tom', 'Jim', 'Mary']
student_tuple = ('Tom', 'Jim', 'Mary')
test_list2set = set(student_list)
test_tuple2set = set(student_tuple)
print(student1)
print(student2)
print("test list covert to set ", test_list2set)
print("test tuple covert to set ", test_tuple2set)
# 成员测试
if 'Rose' in student1:
print('Rose 在集合中')
else:
print('Rose 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print('a=', a)
print('b=', b)
print('a - b=', a - b) # a 和 b 的差集
print('a | b=', a | b) # a 和 b 的并集
print('a & b=', a & b) # a 和 b 的交集
print('a ^ b=', a ^ b) # a 和 b 中不同时存在的元素
def dictionary_demo():
# 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合
# 键(key)必须使用不可变类型
# 在同一个字典中，键(key)必须是唯一的
print('\ntest dictionary')
# 构造
test_dict = {}
test_dict['one'] = "1 - 菜鸟教程"
test_dict[2] = "2 - 菜鸟工具"
print(test_dict)
tinydict = {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
print(tinydict)
# 访问
print(r"tinydict['code']=", tinydict['code'])
print(test_dict['one']) # 输出键为 'one' 的值
print(test_dict[2]) # 输出键为 2 的值
print(tinydict) # 输出完整的字典
print(tinydict.keys()) # 输出所有键
print(tinydict.values()) # 输出所有值
# 构造函数 dict() 可以直接从键值对序列中构建字典如下：
d1 = dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
print(d1)
d2 = {x: x**2 for x in (2, 4, 6)}
print(d2)
d3 = dict(Runoob=1, Google=2, Taobao=3)
print(d3)
def main():
a = b = c = 1 # 允许同时赋值
a, b, c = 1, 2, "runoob" # 允许分别赋值
"""
python3有6种基本数据类型:
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）
"""
# Python3 支持 int、float、bool、complex（复数）
# 内置的 type() 函数可以用来查询变量所指的对象类型,type()不会认为子类是一种父类类型
print(type(a), type(c))
# bool: True False 本质上是1和0
# del语句可以删除一些引用
del c
list_demo()
tuple_demo()
# string、list 和 tuple 都属于 sequence（序列）
set_demo()
dictionary_demo()
if __name__ == '__main__':
main()
扫一扫
1474
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
