Python学习(二):变量和类型

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)

print 是常用的打印函数

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'>