python学习笔记（一）

• python 中没有switch语句。
• 函数通过def关键字定义。
• 使用global语句可以清楚地表明变量是在外面的块定义的，同时也可以指定多个全局变量，如：global x, y, z。

x = 100
z = 404  # 声明一个全局变量


def hello(u):
    global z  # 声明是一个全局变量
    print('pre z is ' + str(z))
    z = 500  # 改变全局变量z的值
    print('now z is ' + str(z))
    print("Hello world!")
    print(4 / 3)  # 浮点除运算
    print(4 // 3)  # 整数除运算
    if u == 1:
        print("233")
    else:
        for i in range(1, 2):
            print(i + 10)


def max1(a, b, to=-1):  # 定义取最大值函数，to默认值是-1，只能放在形参列表末尾才能设置默认值
    if to == -1:
        return max(a, b)
    else:
        return min(a, b)


if __name__ == '__main__':
    x1 = int(input())
    flag = True  # 注意首字母要大写
    hello(x1)
    print("全局变量x的值为：" + str(x))
    print("全局变量z的值为：" + str(z))
    print(max1(1111, 200000, 1))


# pre z is 404
# now z is 500
# 全局变量z的值为：500

• 只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。
• 关键参数：使用名字（关键字）而不是位置来给函数指定实参。
• 没有返回值的return语句等价于return None。
• pass语句在 Python中表示一个空的语句块。
• 文档字符串： docstrings：一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。

"""
    此处是文档字符串，供阅读和参考
"""

• 模块基本上就是一个包含了所有你定义的函数和变量的文件。为了在其他程序中重用模块，模块的文件名必须以.py为扩展名。
• 命令行运行python脚本以及命令行参数：注意，其第一个输出为脚本名称。

import sys  # 引入模块


def count1():
    print("当前命令行参数如下：")
    for index in range(1, len(sys.argv)):  # 打印除脚本名称的命令行参数
        print(sys.argv[index])
    # for i in sys.argv:  # 保证命名不冲突
        # print(i)

测试python命令行参数

• 字节编译的.pyc文件的使用，使得输入模块更
  加快一些。
• 每个Python模块都有它的__name__，如果它是__main__，说明这个模块被用户单独运行，而在它被别的模块输入时不运行主块。

if __name__ == '__main__':
    print("Hello World!")

• 使用内建的dir函数来列出模块定义的标识符。标识符有函数、类和变量。
• 当你为dir(模块名)提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数，它返回当前模块中定义的名称列表。

测试dir函数

删除变量

数据结构

• 有3种：列表，元组和字典。
• 列表是可变的数据类型，元素都存放在[]方括号里面。

if __name__ == '__main__':
    list1 = ['word', 1, 3]
    print(list1)
    list1.append(['you', 2, 3, 5])  # 往列表尾添加一个元素
    print(list1)
    del list1[0]  # 删除列表中的第一个元素
    print(list1)


# ['word', 1, 3]
# ['word', 1, 3, ['you', 2, 3, 5]]
# [1, 3, ['you', 2, 3, 5]]

• 元组：通过圆括号中用逗号分割的项目定义，并且 其不能被修改！！！

元组不能被修改

• 一个空的元组由一对空的圆括号组成，如：tuple2 = ()，然而含有单个元素的元组初始化的时候就得在第一个（唯一一个）项目后跟一个逗号，这样Python才能区分元组和表达式中一个带圆括号的对象。

if __name__ == '__main__':
    tuple1 = (3, 2, 1, (4, 5, 6))  # 元组
    print(tuple1.count(11))  # 统计元素11的个数
    # del tuple1[1]  # 元组不支持被修改
    print(tuple1[2])  # 元组的第3个元素
    print(tuple1.__len__())  # 该元组拥有的元素个数
    tuple2 = (1, )  # 只包含一个元素，需紧跟着逗号才能区分出是元组类型
    print(tuple2)

# 0
# 1
# 4
# (1,)

• 字典：由键值对组成。键必须是唯一的！各个对用逗号分割，所有这些都包括在花括号中。

if __name__ == '__main__':
    dict1 = {'name': "张三", "password": 123456, "email": "10086@233.com"}
    print(dict1)
    print("用户名：" + dict1["name"])
    print("密  码：" + str(dict1['password']))
    item = dict1.items()
    print(type(item))  # 类型为：<class 'dict_items'>
    print("元组的含有元素个数为：" + str(item.__len__()))
    for k, v in dict1.items():  # 遍历元组，打印出所有键值对
        print(k + "：" + str(v))
    print('name' in dict1)  # 检验一个键是否存在字典中
    del dict1['name']  # 删除一个键值对
    print(dict1)  # {'password': 123456, 'email': '10086@233.com'}

• 列表、元组和字符串都是序列，序列的两个主要特点是索引操作符和切片操作符。索引可以是负数，表示位置是从序列尾开始往前计算。

if __name__ == '__main__':  # 主块
    list1 = []
    for i in range(1, 5):
        list1.append(5 - i)
    # 带区间的都是左闭右开区间
    print(len(list1))  # 打印列表含元素的个数，共4个
    print(list1[0])  # 第一个元素
    print(list1[0:])  # 打印[0,3]中的所有元素，[4, 3, 2, 1]
    print(list1[:-1])  # 打印[0,2]中的所有元素，[4, 3, 2]
    print(list1[-1])  # 返回列表的最后一个元素
    print(list1[1:-1])  # 打印[1,2]中的所有元素，[3, 2]
    print(list1[:])  # 打印所有元素，[4, 3, 2, 1]

    list2 = list1  # 引用同一个列表
    print("当前列表为：", list1)  # 当前列表为： [4, 3, 2, 1]
    del list2[0]  # 删除第一个元素
    print("删除元素后的列表list1为", list1)  # 删除元素后的列表list1为 [3, 2, 1]
    print("删除元素后的列表list2为", list2)  # 删除元素后的列表list2为 [3, 2, 1]

• 注意：列表的赋值语句不创建拷贝。你得使用切片操作符来建立序列的拷贝，不然为对象的引用！
• 以下是字符串的其他操作：

if __name__ == '__main__':
    str1 = "Hello World"
    print(str1.startswith('Hell'))  # 测试字符串是否以给定字符串开始
    print('H' in str1)  # True
    if str1.find('o') != -1:  # 若返回-1，则表示找不到子串
        print(str1.find('o'))  # 打印第一次出现的下标
    else:
        print("不存在")
    
    print('~'.join(str1))  # 指定分隔符分割字符串，返回一个大字符串，H~e~l~l~o~ ~W~o~r~l~d
    a = "you are good!"
    b = "That is all right!"
    print("%s" % (a, ))  # 格式化字符串，注意参数使用的是一个元组！！！
    print("%s %s" % (a, b))


# you are good!
# you are good! That is all right!

• id()函数：获取一个对象的内存地址。
• ord()函数：获取一个字符的ASCII或Unicode数值，如：ord('a') = 97。
• chr()函数：用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的ASCII 字符（类型为字符串），如：chr(122)="z"。
• defaultdict()函数：用来创建一个字典，同时实现值的初始化，与dict()函数创建一个普通字典的区别就是前者创建的字典访问任何键都不会抛 KeyError 的异常，即用dict()函数创建的字典若访问不存在的键就会抛出KeyError。两者往字典里添加元素的操作都为：dict[key] =value。

from collections import defaultdict
# 需要提前导入模块才能使用defaultdict()函数

def main():
    dict1 = defaultdict(int)
    dict1['a'] += 1
    dict1[1] += 2
    print(dict1['a'])
    print(dict1['b'])
    print(dict1[1])


if __name__ == '__main__':
    main()

# 输出结果：
# 1
# 0
# 2
# 几个全局初始化值
# defaultdict(int)：初始化键的值为 0
# defaultdict(float)：初始化键的值为 0.0
# defaultdict(str)：初始化键的值为 ''
# defaultdict(list)：初始化键的值为[]

• python 没有自增运算符，why？因为python中的数字类型不可变，当变量值发生改变时，将会新申请一块内存赋值为新值，然后将变量指向新的内存地址。

def main():
    a = 10
    print(id(a))
    b = 10
    print(id(b))
    a = a + 1
    print(id(a))


if __name__ == '__main__':
    main()

# 输出结果：
# 140726418043424
# 140726418043424
# 140726418043456

• 从测试结果来看当a的值发生改变时，a指向的内存地址也发生了改变。而在C语言和其他语言中，a指向的内存地址并不会发生改变，而是改变内存的内容，这也说明了 python 中一个变量值可以被多个名称访问。
• if-else语句：
  1、普通写法；
  2、一行表达式：c = a if a > b else b，条件为真放if前！
  3、二维列表：c= [b, a][a > b]，利用大小判断成0，1当作下标索引。
  4、利用逻辑运算符的特点：c = (a>b and 454545 or 66666)。原理：利用短路特性，若and前位置为假则直接判断为假，且返回0，否则返回第二个值；若or前位置为真则判断为真，且返回第一个值，否则返回第二个值。
• 用in运算符判断字典中是否含有某个key

def main():
    d = {'name': '张三', 'age': 12}
    print(d.keys())  # 列出字典中所有的key
    print('name' in d.keys())
    print('age' in d)
    print('sex' in d)


if __name__ == '__main__':
    main()

# 输出结果：
# dict_keys(['name', 'age'])
# True
# True
# False

• for循环简写：[对(x)的操作 for x in 集合 if 条件]。