python 3.6语法规范 python语言的语法规则

目录

• 一、解释型语言Python
• 二、命名规则
• 三、python基本语法
• 四、python的数据容器----列表、元组、字典、集合

• 1、列表-->list：有序、不唯一的序列

• 列表常用方法
• 列表切片----python独有的
• 嵌套列表

• 2、元组-->array：不可变
• 3、字典-->map：kv格式
• 4、集合-->set：无序唯一

• 集合set的基本语法
• 交集、并集、差集

• 五、python的控制结构----if、for、while

• if选择语句
• for循环结构
• while循环结构
• 列表推导式----python独有的

• 六、文件读写(io)和函数

• 1、读文件

• open()---读取文件返回一个列表
• read()---读取文件，返回所有的数据
• with 语句，简写，自动关闭文件
• 利用python内置的csv模块读取数据
• 读取json格式的数据

• 2、写文件
• 3、python的函数

一、解释型语言Python

Python语言是一种解释型、面向对象、动态数据类型的高级程序设计语言

二、命名规则

Java、Scala命名规则

1、项目名：小写，多个单词用-分割
2、包名：小写，多个包用.分割
3、类名：首字母大写，驼峰命名
4、变量：首字母小写，驼峰命名
5、常量：大写，单词之间用_分割

python与Java、Scala命名规则有一些差异

变量：首字母小写，驼峰命名
变量名必须是大小写英文字母、数字或下划线 _ 的组合，不能用数字开头，并且对大小写敏感 
关键字不能用于命名变量，如and、as、assert、break、class、continue、 def、del等

三、python基本语法

# 获取python的关键字
import keyword
print(keyword.kwlist)

import keyword
# 获取python的关键字
print(keyword.kwlist)

# 定义变量
# 变量的类型可以不指定，会自动推断，而且变量的类型可以修改
a = 100
print(a)    # 100

# 获取变量的类型
print(type(a)) # <class 'int'>

# python中变量类型可以修改---动态数据类型的语言
a = "200"
print(type(a)) # <class 'str'>

# 定义变量的时候手动指定类型
b: int = 100

# 在python编程中，一般使用大写字母定义常量
PI = 3.1415926
print(PI)

# 单行注释

"""
多行注释1：注释的内容包含单引号''
"""

'''
多行注释2：注释的内容包含双引号""
'''

"""
print函数:
    在python2中可以带括号也可以不带括号，在python3中必须带括号
"""

# 打印单个变量
print("python")
# 打印多个变量，需要指定分割方式，不指定的话默认是空格分割
print(1, 2, 3)  # 1 2 3
print(1, 2, 3, sep="|") # 1|2|3

# 整型
a = 100
print(a, type(a)) # 100 <class 'int'>

# 浮点型
f = 3.14
print(f, type(f)) # 3.14 <class 'float'>

# 科学计数法 -- 用于非常大或者非常小的浮点数
f = 3.14e9 # e9：e代替10，表示小数点后面有9位
print(f, type(f)) # 3140000000.0 <class 'float'>

# 字符串：两个单引号或两个双引号包裹起来的文本
# 如果文本中有双引号外面就用单引号，文本中有单引号外面用双单引
# 报错：s = 'java,spark',python'
s = 'java,spark",python'
print(s, type(s)) # java,spark",python <class 'str'>

# 转义字符串
print("java \t  python")  # 制表符: java    python
print("java \n  python")  # 换行
print(r"java \n  python")  # 显示原始数据：java \n  python

# 布尔值
print(100 > 1) # True
print(100 < 1) # False
# 布尔运算
print(True and True) # True
print(True or True) # True
print(True & False) # False
print(True | True)  # True
print(not True)  # 取反：False
print(not 100 > 1) # False

# 空值
n = None
print(n, type(n)) # None <class 'NoneType'>

# 算术计算
i = 10
j = 3

print(i + j) # 13
print(i - j) # 7
print(i * j) # 30
print(i / j) # 3.3333333333333335
print(i // j) # 向下取整：3
print(i ** j) # i的j次方：1000
print(i % j) # 1

print("=" * 50)

# 类型转换
s = "100"
print(s, type(s)) # 100 <class 'str'>

# 将字符串转换成int类型
i = int(s)
print(i, type(i)) # 100 <class 'int'>

# 将字符串转换成浮点型
s = "3.14"
f = float(s)
print(f, type(f)) # 3.14 <class 'float'>

s = str(f)
print(s, type(s))

# 类型转换异常
# s = "python"
# i = int(s)
# print(i, type(i))
# print("=" * 100)

# 只有在变量值为0或者None时，bool转换的结果才为 False
print(bool("0")) # True
print(bool(0))  # False
print(bool(None))  # False

# 判断变量是不是某一类型
s = "java"
print(isinstance(s, str)) # True

四、python的数据容器----列表、元组、字典、集合

1、列表-->list：有序、不唯一的序列

列表(list)是一个有序的序列结构，序列中的元素可以是不同的数据类型
列表可以进行一系列序列操作，如索引、 切片、加、乘和检查成员等

定义列表：[2,'java','python','Hive SQL']

列表常用方法

# 列表：有序，不唯一的序列

# 定义列表，列表中点的元素类型可以不一致
list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list, type(list)) # [1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>

# 定义一个空的列表
list = []
# 向列表中追加元素
list.append(1)
list.append(2)
list.append(3)
print(list) # [1, 2, 3]

# 插入元素并指定下标
list.insert(1, 100)
print(list) # [1, 100, 2, 3]

# 通过下标获取元素
print(list[1]) # 100

# 修改指定下标的值（更新元素）
list[1] = 200
print(list) # [1, 200, 2, 3]

list.append(200)
print(list) # [1, 200, 2, 3, 200]
# 删除元素, 如果有相同的元素，按照顺序删除
list.remove(200)
print(list) # [1, 2, 3, 200]

# 指定下标删除元素
del list[0]
print(list) # [2, 3, 200]

# 取出指点下标的元素，取出来不放回
print(list.pop(1)) # 3
print(list) # [2, 200]

# python中下标有两种
# 1、从左往右，0到N
# 2、从右往左，-1到-N-1
list = [1, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 查询下标为0的元素
print(list[0]) # 1

# len获取集合的长度
# 获取最后一个元素
print(list[len(list) - 1]) # 9
print(list[-1]) # 9

# 统计集合中指定元素的数量
print(list.count(1)) # 2

# 清空集合
# list.clear()
# print(list) # []

# 复制一个新的集合
list2 = list.copy()
print(list2) # [1, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 插入多个元素
list.extend([4, 5, 6, 7, 8])
print(list) # [1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4, 5, 6, 7, 8]

# 查询元素在集合中第一个出现的位置（下标）
print(list.index(4)) # 4

# 反转集合
list.reverse()
print(list) # [8, 7, 6, 5, 4, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1]

# 对集合进行排序，默认是升序
list.sort()
print(list) # [1, 1, 2, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9]
# reverse 是否降序
list.sort(reverse=True) # 降序
print(list) # [9, 8, 8, 7, 7, 6, 6, 5, 5, 4, 4, 3, 2, 1, 1]

列表切片----python独有的

列表切片语法：列表名称[起始索引位置：最后索引位置：步长]

(1)切片操作需要提供起始索引位置和最后索引位置，然后用冒号 : 将两者分开 (2)如果未输入步长，则默认步长为 1 (3)切片操作返回一系列从起始索引位置开始到最后索引位置结束的数据元素 (4)需要注意的是，起始索引位置的值包含在返回结果中，而最后索引位置的值不包含 在返回结果中

list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 将元素中的4、5、6取出来（含头不含尾）
print(list[3:6]) # [4, 5, 6]

# 从头到尾截取数据（开始和结束位置都不写）
print(list[:]) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 指定负下标截取
print(list[-6:-3]) # [4, 5, 6]

# 反向截取，步长为负数
print(list[5:2:-1]) # [6, 5, 4]

# 反转
print(list[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1]

# 每间隔一个元素截取一个
print(list[::2]) # [1, 3, 5, 7, 9]
print(list[1:8:2]) # [2, 4, 6, 8]

嵌套列表

# 嵌套列表
list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(list) # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 获取第一个元素
print(list[0]) # [1, 2, 3]
# 获取第一个元素的第一个元素
print(list[0][0]) # 1

2、元组-->array：不可变

元组(tuple)数据结构与列表类似，其中元素可以有不同的类型 但是元组中的元素是不可变的： 即一旦初始化之后，就不能够再做修改(报错:元组对象不支持 赋值) 定义元组：(2,'java','python','Hive SQL')

# 元组：不可变的列表
# 元组除了不能增删改元素外，其它列表的方法都有
tuple = (1, 1, 2, 3, 4, 5, 6, 7, 8)
print(tuple) # (1, 1, 2, 3, 4, 5, 6, 7, 8)
# 统计指定元素的数量
print(tuple.count(1)) # 2

# 查询元素在集合中第一个出现的位置（下标）
print(tuple.index(4)) # 4

# 查询指定下标元素
print(tuple[0]) # 1

# 切片
print(tuple[::-1]) # (8, 7, 6, 5, 4, 3, 2, 1, 1)

3、字典-->map：kv格式

字典就是通过单词查意思，也就是通过key查value

字典(dict)在其他语言中被称作哈希映射(hash map) 或者相关数组(associative arrays)
字典是一种大小可变的键值对集，其中的键(key)和 值(value)都是Python对象
字典用在需要高速查找的地方

# 定义字典
user = {
    "001": "张三",
    "002": "李四",
    "003": "王五"
}

# 通过key获取value
# 方法1
print(user.get("001")) # 张三
# 如果key不存在返回None
# print(user.get("0011")) # None
# 方法2
print(user["001"])
# 如果key不存在会报错
# print(user["0011"])  报错

# 取出，不放回
print(user.pop("001")) # 张三
print(user) # {'002': '李四', '003': '王五'}

# 获取所有的key
keys = user.keys()
print(keys) # dict_keys(['002', '003'])
# 获取所有的value
values = user.values()
print(values) # dict_values(['李四', '王五'])

# 更新元素，如果key存在就更新，如果key不存在就插入
user["002"] = "赵六"
print(user) # {'002': '赵六', '003': '王五'}

# 插入元素
user["001"] = "张三"
print(user) # {'002': '赵六', '003': '王五', '001': '张三'}

# 删除元素
del user["001"]
print(user) # {'002': '赵六', '003': '王五'}

# 循环
# 只循环key
for i in user:
    print(i)  # 002
              # 003
# 循环key、value
for key,value in user.items():
    print(key,value)    # 002 赵六
                        # 003 王五

# 将字典转换成列表，里面的元素转换成元组
print(user.items()) # dict_items([('002', '赵六'), ('003', '王五')])

# 循环构建字典
# 1、定义key和value
keys = [1, 2, 3, 4, 5, 6, 7, 8]
values = ["a", "b", "c", "d", "e", "f", "g", "H"]
# 2、定义一个空的字典
d = {}
# 3、使用zip ：将两个长度一样的列表放一起循环
for key, value in zip(keys, values):
    # 向空字典中循环增加元素
    d[key] = value

print(d) # {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'H'}

# 判断key是否存在
print(1 in d) # True

4、集合-->set：无序唯一

集合(set)是一种无序集，它是一组键的集合，重复的键是不被允许的。

集合可以用于去除重复值

集合也可以进行数学集合运算，如并、交、差以及对称差等。

应用:
去重：把一个列表变成集合，就自动去重了
关系测试：测试两组数据之前的交集、差集、并集等关系

集合set的基本语法

# 定义集合set，会自动去重
s = {1, 2, 3, 4, 5, 5, 6, 44, 3, 31, 2, 2}
# 或者 s = set([1, 2, 3, 4, 5, 5, 6, 44, 3, 31, 2, 2])
print(s) # {1, 2, 3, 4, 5, 6, 44, 31}
# 创建空的集合，必须使用set()
s1 = set()

# 向集合中添加元素
s.add(100)
print(s) # {1, 2, 3, 4, 5, 6, 100, 44, 31}

# 删除指定的元素
s.remove(1)
print(s) # {2, 3, 4, 5, 6, 100, 44, 31}

# 取出一个元素（随机）
print(s.pop())  # 2
print(s) # {3, 4, 5, 6, 100, 44, 31}

交集、并集、差集

s1 = {1, 2, 3, 4, 5, 6, 7}
s2 = {4, 5, 6, 7, 8, 9, 10}
# 并集
print(s1 | s2) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

# 交集
print(s1 & s2) # {4, 5, 6, 7}

# 差集
print(s1 - s2) # {1, 2, 3}

# 返回只有一个中有的（s1或s2不同时属于s1和s2的元素）
print(s1 ^ s2) # {1, 2, 3, 8, 9, 10}

五、python的控制结构----if、for、while

if选择语句

age = 20

if age > 18:
    print("成年")
elif age == 18:
    print("刚好成年")
else:
    print("未成年")

for循环结构

# 定义一个列表
list1 = [1, 2, 3, 4]
# 循环
for i in list1:
    print(i)
# 结果
    1
    2
    3
    4

# 循环的时候获取下标
for index, i in enumerate(list1):
    print(index, i)
# 结果
    0 1
    1 2
    2 3
    3 4
==================================================
# 定义一个字典
user = {
    "001": "张三",
    "002": "李四",
    "003": "王五"
}
# 循环key，通过ley获取value
for key in user.keys():
    print(key, user[key])
# 结果
    001 张三
    002 李四
    003 王五
    
# 直接循环获取kv
for k, v in user.items():
    print(k, v)
# 结果
    001 张三
    002 李四
    003 王五

while循环结构

# while循环
i = 0
while i <= 100:
    print(i)
    i += 1	# python中没有i++
# 结果
    0
    1
    2
    ...
    99
    100

列表推导式----python独有的

使用列表推 导式可以让循环在列表内完成

# 对集合中的元素进行处理，求每个元素的平方
list2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 定义一个新的空列表
new_list = []
for i in list2:
    new_list.append(i ** 2)
print(new_list)  # [1, 4, 9, 16, 25, 36, 49, 64, 81]

# 使用列表推导式，对上面代码的简写
list3 = [i ** 2 for i in list2]
print(list3) # [1, 4, 9, 16, 25, 36, 49, 64, 81]

六、文件读写(io)和函数

1、读文件

open()---读取文件返回一个列表

# 读取文件
# 打开文件--open，指定文件路径和打开的方式，r:读，w:写，a:追加
# 指定编码
f = open("students.txt", mode="r", encoding="utf-8")

# 读取所有行，得到一个列表
# 每一行后面都有换行
lines = f.readlines()

# 读完数据后需要关闭文件
f.close()

print(lines) # ['1500100001,施笑槐,22,女,文科六班\n', '1500100002,吕金鹏,24,男,文科六班\n', '1500100003,...]

# 去点数据中的换行符，使用strip()
lines = [line.strip() for line in lines]
print(lines) # ['1500100001,施笑槐,22,女,文科六班', '...]

read()---读取文件，返回所有的数据

f = open("students.txt", mode="r", encoding="utf-8")
# 读取所有的数据，得到一个字符串
content = f.read()
print(content, type(content))
#结果
1500100001,施笑槐,22,女,文科六班
1500100002,吕金鹏,24,男,文科六班
1500100003,单乐蕊,22,女,理科六班
...
1500100337,游孤风,22,女,理科三班 <class 'str'>
f.close()

with 语句，简写，自动关闭文件

with open("students.txt", mode="r", encoding="utf-8") as f: # 起个别名f
    # 读取所有行
    ls = f.readlines()

print(ls)
# ['1500100001,施笑槐,22,女,文科六班\n', '1500100002,吕金鹏,24,男,文科六班\n', '1500100003,...]

利用python内置的csv模块读取数据

import csv # 引入csv模块

with open("students.txt", mode="r", encoding="utf-8") as f:
    # 使用csv解析文件，默认是逗号分割
    reader = csv.reader(f)
    # 循环
    for stu in reader:
        print(stu)
        
# 结果
['1500100001', '施笑槐', '22', '女', '文科六班']
['1500100002', '吕金鹏', '24', '男', '文科六班']
['1500100003', '单乐蕊', '22', '女', '理科六班']
....

读取json格式的数据

# 导入解析json的包，官方包
import json

json_str = '{"age":22,"clazz":"理科六班","gender":"女","id":"1500100008","name":"符半双"}'

# 解析json字符串
# 将json字符串自动转换成字典
json_obj = json.loads(json_str)
print(json_obj) # {'age': 22, 'clazz': '理科六班', 'gender': '女', 'id': '1500100008', 'name': '符半双'}
print(json_obj["id"]) # 1500100008
print(json_obj["name"]) # 符半双
age = json_obj["age"] # 不能自动在代码中推断类型，运行的时候知道类型
print(age, type(age)) # 22 <class 'int'>


# 批量解析json
with open("students.json", "r", encoding="utf-8") as f:
    # 读取所有的数据
    lines = f.readlines()
    
    students = [json.loads(line) for line in lines]

for student in students:
    print(student, type(student))

2、写文件

# 定义一列表
list66 = ["java", "spark", "hadoop", "java"]

# mode=w ：覆盖写入，mode=a：追加写入
with open("list.txt", mode="a", encoding="utf-8") as f:
    # 向文件中写入一条数据
    f.write("java")
    f.write("\n")  # 换行
    f.write("hadoop")
    f.write("\n")  # 换行

    # 向文件中写入多条
    f.writelines(list66)
    
# 结果会生成一个list.txt文件，文件内包含写入的数据
    java
    hadoop
    javasparkhadoopjava

3、python的函数

# 定义函数
# 函数参数的类型可以不指定，随便怎么用
# 参数类型可以手动指定
def square(x: int, y: int):
    i = x ** y # x的y平方
    # 返回值
    return i


# 函数的调用
i = square(100, 2)
print(i) # 10000

# 定义一个函数，不指定类型
def fun(x, y):
    return x * y

# 起义
print(fun("100", 2)) # 100100
print(fun(100, 2)) # 200

# lambda 表达式, 如果以函数作为参数的时候可以使用lambda表达式简写
f = lambda x, y, z: x * y * z

print(f(1, 2, 3)) # 6