1. 第一个程序
工作中一般都是使用PyCharm 进行开发，这里就直奔主题，直接展示一个程序的简单结构:
1.1 简单层级结构
1.2 示例源码
main.py代码如下:
# 导入其他包
import basis.grammar
# 程序入口
if __name__ == '__main__':
# 调用其他包里的函数
sumRes = basis.grammar.get_sum(1, 3)
# 打印函数返回结果
print("求和结果:", sumRes)
# 打印常量
print("常量:", basis.grammar.PACKAGE_DESC)
grammar.py代码如下:
# 定义常量
PACKAGE_DESC = "语法学习演示代码"
# 求两个数的和
def get_sum(a, b):
"""
:param a: 参数a
:param b: 参数b
:return:
"""
return a + b
在
Python中，注释用井号（#）标识。井号后面的内容都会被Python解释器忽略。养成注释的好习惯~多行注释用三个引号，单引号和双引号都行，推荐使用双引号，一般常用于函数的描述如下:
""" 我是多行注释 我是多行注释 """
1.3 运行程序
- 第一种方法: 程序入口函数旁边有个绿色三角形,右键选择
Run 'main'； - 第二种方法: 在终端执行
python main.py
2. 变量和常量
2.1 定义使用
Python是一门动态类型的语言，无须预先声明变量类型，直接对变量赋值即可。
# 定义一个变量
name = "张三"
# 一行定义多个变量
name, age = "张三", 18
# 定义常量，常量一般用大写
PACKAGE_DESC = "语法学习演示代码"
2.2 命令规范
为了让不同开发者写出的代码风格尽量保持统一，Python制定了官方的编码风格指南：PEP8，其中对变量和常量的命名规范也给出了建议:
- 对于普通变量，使用蛇形命名法，比如
user_id；全局变量名,采用global_开头，比如:global_var_name - 变量名只能包含字母、数字和下划线;但不能以数字打头,如
1_var; - 变量名不能包含空格，可使用下划线来分隔其中的单词；
- 不要将
Python关键字和函数名用作变量名; - 对于常量，采用全大写字母，使用下划线连接，比如
PACKAGE_DESC；全局常量名,采用GLOBAL_开头，比如:GLOBAL_CONSTANT_NAME; - 如果变量标记为包内部变量，为其增加下划线前缀，比如
_local_var；
3. 内置类型
3.1 字符串
字符串就是一系列字符。在Python中，用引号括起的都是字符串，其中的引号可以是：单引号、双引号、三引号；如下所示：
# 程序入口
if __name__ == "__main__":
# 双引号
first_str = "Hello"
# 单引号
two_str = "World"
# 三引号
text = """第一行:123
第二行: 456,
第三行: 789。
"""
print("first_str:", first_str, "two_str:", two_str)
print("text:", text)
## 输出
# first_str: Hello two_str: World
# text: 第一行:123
# 第二行: 456,
# 第三行: 789。
3.2 数字
在Python中,数字类型又可以分为整型和浮点型两种，定义时不需要声明具体类型,使用函数type(变量名)，可以查看该变量的具体类型。
# 程序入口
if __name__ == "__main__":
# 定义整型
int_val = 10
# 定义浮点型
float_val = 3.3
# 整除
r1 = int_val/2
# 有余数
r2 = int_val/4
# 除不尽
r3 = int_val/float_val
print("整除:", r1, "值类型：", type(r1))
print("有余数:", r2, "值类型：", type(r2))
print("除不尽:", r3, "值类型：", type(r3))
## 输出
# 整除: 5.0 值类型： <class 'float'>
# 有余数: 2.5 值类型： <class 'float'>
# 除不尽: 3.0303030303030303 值类型： <class 'float'>
在
Python 2中，整数除法的结果只包含整数部分，小数部分会被直接删除，比如3/2 = 1；
3.3 列表
在Python中，用方括号[]来声明列表，并用逗号来分隔其中的元素;列表是有序集合，通过索引访问元素，访问规则如下：
- 访问单个元素，使用
list_x[A]; - 访问多个元素，使用
list_x[A:B]；当A省略时,表示从索引0开始，当B省略时,表示到列表最后；
if __name__ == "__main__":
# 定义列表
number_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 访问第1个元素
print("访问第1个元素,number_list[0]: ", number_list[0])
# 访问倒数第2个元素
print("访问倒数第2个元素,number_list[-2]: ", number_list[-2])
# 访问从第2位到第5位的元素
print("访问从第2位到第5位的元素,number_list[1:5]: ", number_list[1:5])
# 从倒数第3个元素，到最后
print("从倒数第3个元素，到最后,number_list[-3:]: ", number_list[-3:])
# 访问第1个元素,number_list[0]: 1
# 访问倒数第2个元素,number_list[-2]: 8
# 访问从第2位到第5位的元素,number_list[1:5]: [2, 3, 4, 5]
# 从倒数第3个元素，到最后,number_list[-3:]: [7, 8, 9]
3.4 集合
集合中不会有重复的元素。可使用大括号{}来定义集合，也可使用set()函数来创建集合。
因为集合无序，所以它不能像列表（
list）或元组（tuple）那样,可以通过索引访问指定位置的元素。但是可以把集合使用关键字list转成列表后，再进行访问操作。
# 程序入口
if __name__ == "__main__":
# 使用{}定义集合
set_var = {10, 10, 20, 20, 30, 40}
print("set_var: ", set_var)
# 集合转成列表
set_to_list = list(set_var)
print("set_to_list: ", set_to_list[:])
print("set_to_list[0]: ", set_to_list[0])
print("set_to_list[-1]: ", set_to_list[-1])
# 使用set函数创建集合
list_var = [1, 2, 3, 4, 3, 2, 1]
set_func_var = set(list_var)
print("set_func_var: ", set_func_var)
print("set_func_var.type: ", type(set_func_var))
# set_var: {40, 10, 20, 30}
# set_to_list: [40, 10, 20, 30]
# set_to_list[0]: 40
# set_to_list[-1]: 30
# set_func_var: {1, 2, 3, 4}
# set_func_var.type: <class 'set'>
3.5 元组
在Python中定义元组时使用的符号是小括号()，元组用起来和列表几乎一样，需要注意的是：元组中的元素绝大部分不可修改。
# 程序入口
if __name__ == "__main__":
# 定义元组
tuple_var = (1, "hello", [10, 20], "world")
# 打印元组
print("tuple_var: ", tuple_var)
print("tuple_var[0]: ", tuple_var[0])
print("tuple_var[2]: ", tuple_var[2])
print("tuple_var[1:]: ", tuple_var[1:])
# 修正元组中的列表元素
tuple_var[2][0] = 100
print("修正元组中的列表元素: ", tuple_var)
# tuple_var: (1, 'hello', [10, 20], 'world')
# tuple_var[0]: 1
# tuple_var[2]: [10, 20]
# tuple_var[1:]: ('hello', [10, 20], 'world')
# 修正元组中的列表元素: (1, 'hello', [100, 20], 'world')
@注意:元组的元素绝大部分是不能修改的，但是当元素是列表时，可以修改列表中的值，如上面示例把元素列表[10,20]改成[100,20]。
3.5 字典
在Python中，字典是一系列键—值对。键可以是数字、字符串、元组；值可以是Python中的任何对象。
if __name__ == "__main__":
# 定义字典
dict_var = {
1: '键是:数字', # 键为数字
'name': '键是:字符串', # 键为字符串
(1, 2, 3): '键是:元组', # 键为元组
}
# 访问字典
print("打印字典:", dict_var)
print("访问key=1的值:", dict_var[1])
print("访问key=name的值:", dict_var['name'])
print("访问key=(1, 2, 3)的值:", dict_var[(1, 2, 3)])
# 字典中追加元素
dict_var["age"] = 20
print("打印追加后的字典:", dict_var)
# 修改字典中的值
dict_var["name"] = "张三丰"
print("修改字典中的name:", dict_var)
# 打印字典: {1: '键是:数字', 'name': '键是:字符串', (1, 2, 3): '键是:元组'}
# 访问key=1的值: 键是:数字
# 访问key=name的值: 键是:字符串
# 访问key=(1, 2, 3)的值: 键是:元组
# 打印追加后的字典: {1: '键是:数字', 'name': '键是:字符串', (1, 2, 3): '键是:元组', 'age': 20}
# 修改字典中的name: {1: '键是:数字', 'name': '张三丰', (1, 2, 3): '键是:元组', 'age': 20}
4.类型转换
4.1 数字转字符串: str()
开发过程中会经常出现字符串和数字拼接的情况，如果直接拼接则会报错,需要使用函数str()把数字转成字符串；
# 程序入口
if __name__ == "__main__":
# 定义数字
age = 18
# 定义字符串
name = "张三 "
# 拼接
print("错误示例: ", name + age)
# print("正确示例: ", name + str(age))
# Traceback (most recent call last):
# File "/Users/liuqh/ProjectItem/PythonItem/python-learn-demo/main.py", line 14, in <module>
# print("错误示例: ",name + age)
# ~~~~~^~~~~
# TypeError: can only concatenate str (not "int") to str
4.2 字符串转数字: int()
if __name__ == "__main__":
# 定义数字
a = 10
# 定义字符串数字
b = "5"
# 相加
print("相加结果: ", a + int(b))
# 相加结果: 15
4.3 列表转集合: set()
if __name__ == "__main__":
# 定义列表
list_var = [1, 2, 3, 3, 2, 1]
# 转为集合
set_var = set(list_var)
print("set_var:", set_var)
print("set_var type:", type(set_var))
# set_var: {1, 2, 3}
# set_var type: <class 'set'>
4.4 集合转列表: list()
if __name__ == "__main__":
# 定义集合
set_var = {1, 2, 3, 3, 2, 1}
# 转为列表
list_var = list(set_var)
print("list_var:", list_var)
print("list_var type:", type(list_var))
# list_var: [1, 2, 3]
# list_var type: <class 'list'>
微信搜索【猿码记】查看更多文章
本文由mdnice多平台发布
