一、python语法
1.首行注释
创建python文件后，第一行就是# coding-utf-8 告诉编译器，使用的编码格式为utf-8。一般情况下会空一格，编码习惯。然后就是导入包比如import os，最后就是写入逻辑内容，比如print() 语句，而且在导入语句后面要空两行，也是比较好的编程习惯。
2.程序入口
在python中有固定的写法if __name__ == '__main__': 这和缩进是能联系在一起的，这条语句中可以看到一个： 看到这个符号后，下面的语句要在前面空出1个tab键或者是4个空格。
在1中已经导入了os模块，那么我们可以在程序入口缩进的部分使用print(os.getcwd()) 打印当前文件的位置。而且要注意在程序入口之后最好不要再出现代码，把所有想写的代码都写到程序入口之前，因为python脚本执行的顺序是从左到右，从上到下。
os模块中的getcwd函数是用于获取当前文件的路径的。
上述两点的整体代码如下：

# coding-utf-8

import os


print('圣彼得堡天天下雪')

if __name__ == '__main__':
    print(os.getcwd())

3.print语句
print语句用于把我们想要打印的内容打印到控制台上，具体的用法为print() 在括号中输入我们想要打印的内容就可以了。
比如：

print('圣彼得堡最近一直在下雪，')
print('就很烦。')

这样使用后运行的结果是编译器自己换行的。那我们想要让这两条输出在同一行中，变成一句话，就可以使用下列两种方式实现。方法一，把两条字符串的内容使用逗号隔开，然后放到同一条print语句中。实现：print('圣彼得堡最近一直在下雪，','就很烦。' )。方法二，使用end将两个print打印的语句连接到一起。实现：
print('圣彼得堡最近一直在下雪，', end='') print('就很烦。')。
4.变量
变量通俗的说就是从计算机内存中取了一块空间用于存储一个可以改变的值，这个值可以是字符串，可以是数字等等。用代码实现，比如：

username = '小明'
age = 3
if __name__ == '__main__':
	print(username)
	print(age)

首先我们定义了两个变量，第一个变量是username，并赋值为小明，是字符串类型的；第二个变量是age，并赋值为3，是数字类型的。然后在程序入口处进行打印，运行脚本后我们就可以拿到username和age的值了。
5.input
对于input语句，在python中固定的语法是变量 = input() 变量是用于储存input输入语句运行后产生的值。
实现：

name = input('你的名字是：') 
subjects = input('你喜欢的科目是：')

print('你的名字是：%s, 你喜欢的科目是：%s ' %
      (name, subjects))

这样脚本运行后，就可以在控制台显示input中的内容，当输入文本后，代码顺序执行，然后我们就可以看到在控制台输入的内容被打印出来了。
二、数据类型
python中有8种数据类型，数值类型，字符串，布尔值，列表，元组，字典，集合，空类型。
1.数值类型（不可变类型）
主要有整数和浮点数。主要进行整数和浮点数的定义。

age = 13
weight = 66.7
if __name__ == '__main__':
    print(age)
    print(weight)
    print(type(age))
    print(type(weight))

在定义了整形变量age和浮点型变量weight后，在程序入口函数中对变量进行输出，然后使用type方法对变量的类型进行输出。
type方法：type方法可以用于各种数据类型，用于数值类型中，可以检测当前的变量是属于说明类型的，然后返回的是数据类型。
2.字符串（不可变类型）
字符串通俗的说就是单引号(双引号)中的若干字符。例子：

name = '小明'
name_02 = '小智'

new_name = name
print(id(new_name))
print(id(name))
print(id(name_02))
print(type(name))
print(type(name))

这段代码主要有三个知识点。第一点就是定义了name和name_02之后可以使用id方法查看当前的字符串内存。第二点是type也可以使用在字符串中，返回的依然是变量的数据类型。第三点是当对new_name进行赋值之后，打印new_name和name的地址，发现二者的地址是相同的。如果对name进行改变，然后再变回name中的赋值，最后使用id查看地址，发现二者的地址是不相同的，这也说明字符串是一个不可变类型。
字符串的拼接，用于文本的连接。连接两个字符串，形成一个新的字符串。

str1 = 'Hello' + 'World'
print(str1)
print(len(str1))
print(type(str1))
print(min(str1))
print(max(str1))

除了字符串拼接之外，我们还可以使用len方法查看字符串的长度。
也可以使用type方法查看当前变量str1的类型，返回当前变量的数据类型。
还可以根据Unicode编码对字符串大小进行比较，比较当前字符串中最大值的是max方法，比较当前字符串中最小值的是min方法。
3.布尔值类型和空类型
布尔值类型的数据表示逻辑运算结果，有两种取值：真，使用True关键字表示。假，使用False关键字表示。
False None 0 “” () [] {} 这些值使用布尔值类型查看的时候表示False，这里的0不管是整形的还是浮点型的，使用bool查看的时候都是False。其他的使用bool查看的时候都是bool。主要使用bool方法进行检测。
空类型是使用None表示，然后使用bool类型检测的结果也是False。

a = 0
b = 0.0
c = None
d = ()
e = False
f = []
g = {}
print(bool(a))
print(bool(b))
print(bool(c))
print(bool(d))
print(bool(e))
print(bool(f))
print(bool(g))

a = 1
b = 2.2
print(a == b)
print(a != b)
print(a > b)
print(a >= b)
print(a < b)
print(a <= b)

is 和 is not 用来比较两个对象。 在CPython中，比较的是对象的内存地址。 Python中的一切都是对象，每个对象都存储在特定的内存位置， is 和 is not '检查两个变量是否引用内存中的同一个对象。

a = 1
b = 2.2
print(a is b)
print(a is not b)

4.列表
列表是一个有序的序列，列表中所有的元素放在[]中间，并用逗号分开，但是如果只有一个元素的话就要在最后一个元素后面加一个逗号[1,]。
列表也可以使用运算符进行运算。
运算符+连接两个列表

list1 = [1,2]
list2 = [3,4]
print(list1+list2)

运算符*，运算符*将列表的元素重复。

list1 = [1,2]
list2 = list1 * 2
print(list2)

索引[]，通过索引[]获取列表中指定位置的元素。

list1 = ['a', 'b', 'c']
print(list1[0])

索引[:]，在python中使用语法列表[start:end]，获取列表，包含start，不包含end。

list1 = ['a','b','c']
print(list1[1 : 3])

关键字in检查列表中是否包含指定元素

print('a' in ['a', 'b', 'c'])

常见函数
len(列表)函数，使用函数len获取列表的长度

print(len([1, 2, 3]))

max(列表)，使用函数max获取列表中最大的元素

print(max([1,2,4]))

min(列表），使用函数min获取列表中最小的元素

print(min([1, 2, 4 ]))

常见方法
append(item)方法向列表中新增一个元素item，append方法默认将元素添加到列表的最后一个位置。

x = [1, 2, 3]
y = x.append(4)
print(x)

insert(index,item)方法用于将元素item插入到列表的指定位置。

x = ['a', 'b', 'c']
y = x.insert(1,'d')
print(x)

pop()方法从列表的尾部取走一个元素。

x = ['a', 'b', 'c']
item = x.pop()
print(item)
print(x)

从x列表中使用pop方法取走一个元素后，x = [‘a’, ‘b’] ，然后打印的item为c。
remove(item)方法从列表中删除指定元素item。

x = ['a', 'b', 'c']
x.remove('a')
print(x)

index(item)方法在列表中查找指定元素item，如果找到元素item，则返回元素item的索引；如果找不到，则抛出异常。

x = ['a', 'b', 'c']
print(x.index('a'))
print(x.index('d'))

当使用index方法查询’a’字符串的时候，显示为1。使用index方法查询’d’字符串的时候，抛出异常ValueError: 'd' is not in list。
reverse()方法将列表中元素倒序排列。

x = ['a', 'b', 'c']
x.reverse()
print(x)

sort()方法对列表中元素进行排序。
按递增排序，缺省情况下，sort方法对列表中的元素按递增进行排序。在定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数。

x = [1, 3, 2]
x.sort()
print(x)

按递减排序，通过使用选项reverse=True 让列表按递减排序。这里需要注意这里的True首字母是大写，如果是小写就会抛出异常NameError: name 'true' is not defined。

x = [1, 3, 2]
x.sort(reverse=True)
print(x)

5.元组
元组是一个有序的只读序列，元组中所有的元素放在()中间，并用逗号分开。
元组和列表的最大区别是：列表创建后可以修改，但是元组创建后，不能进行修改。

x1 = [1, 2, 3]
x1[0] = 11
print(x1)
y1 = (1, 2, 3)
y1[0] = 11
print(y1)

上述代码分别对列表和元组创建后进行了修改，运行后显示修改列表成功，修改元组抛出异常TypeError: 'tuple' object does not support item assignment，异常信息也表明了元组不可以进行修改。
如果一个元组没有包含任何元素，使用()表示一个空元组。

t = ()
print(t)

如果一个元组只包含一个元素item，需要在元素后加一个逗号，使用(item,)表示该元组。

t = (123,)
print(t)

(123,)和(123)表示不同的含义：
(123,)表示的是一个元组，元组中包含一个整数123。(123)表示的是一个带括号的表达式，整数123嵌入括号中。

t1 = (123,)
t2 = (123)
print(t1 == 123)
print(t2 == 123)

元组的简写，当元组在赋值操作符=的右边时，可以省略括号。

t1 = 123, 456
print(t1)
t2 = 123,
print(t2)

常见的运算符操作
运算符+，使用运算符+连接连个元组

print((1, 2) + (3, 4))

运算符*，使用运算符*将元组重复。

t = (1, 2)
t1 = t*2
print(t1)

索引[] 获取元组中指定位置的元素。

x = ('a', 'b', 'c')
print(x[0])

索引[ : ]中，使用语法[start : end]，获取这个范围内的字符串，包含start，不包含end。

x = ('a', 'b', 'c')
x[1: 3]

关键字in，检查元组中是否包含指定元素。

'a' in ('a', 'b', 'c')
'd' in ('a', 'b', 'c')

返回的都是布尔值，如果在元组中返回True，不在元组中返回False。
常见函数
len(元组)获取元组的长度。

len((1, 2, 3))

max(元组）函数获取元组中最大的元素

max((1, 2, 3))

min(元组) 函数获取元组中最小的元素

min((1, 2, 3))

常见方法只有index(item)方法，因为大多数能在列表中能用的方法不能用于元组中，元组创建后，不能进行修改。
index(item)方法在元组中查找指定元素item的索引，如果找到item，则返回item的索引。如果找不到，则抛出异常。

x = ('a', 'b', 'c')
print(x.index('a'))
print(x.index('d'))

当然在元组中也可以放入列表，数值类型，布尔类型，字符串类型，或者是元组的嵌套，都是没有问题的。

t0 = ([1, 2, 3])
t1 = (1, 2, 3)
t2 = (bool(1))
t3 = ('s', 'c')
t4 = (bool((1,)))
print(t0)
print(t1)
print(t2)
print(t3)
print(t4)

6.字典
字典由键和对应值成对组成，字典中所有的键值对放在{}中间，每一对键值之间使用逗号隔开。

{'a': 'A', 'b': 'B', 'c': 'C'}
{1: 100, 2: 200, 3: 300}

字典通常描述对象的各种属性，例如一本书，有书名，作者名，出版社等各种属性。

book = {'title': '数学之美', 'author': '张三', 'press': '机械工业出版社'}
print(book['title'])

常见操作；
读取字典；

x = {'a': 'A', 'b': 'B'}
print(x['a'])

修改字典；

x = {'a': 'A', 'b': 'B'}
x['a'] = 'AA'
x['b'] = 'BB'
print(x)

在字典中增加键值对；

x = {'a': 'A', 'b': 'B'}
x['c'] = 'C'
print(x)

在字典中删除键值对；

x = {'a': 'A', 'b': 'B', 'c': 'C'}
del x['b']
print(x)

查询字典；
通过关键字in检查字典中是否包含指定元素。

x = {'a': 'A', 'b': 'B'}
print('a' in x)
print('c' in x)

常见函数；
len(字典)函数获取字典中键值对的数量。

x = {'a': 'A', 'b': 'B'}
print(len(x))

常见方法；
clear()方法删除字典中所有的键值对。

x = {'a': 'A', 'b': 'B'}
x.clear()
print(x)

pop(key)方法删除字典中给定键key所对应的键值对，返回被删除的值。

x = {'a': 'A', 'b': 'B', 'c': 'C'}
x.pop('b')
print(x)

遍历字典；
使用for key in dict遍历所有的键

x = {'a': 'A', 'b': 'B'}
for key in x:
    print(key)

使用for key in dict.keys()遍历字典的键

x = {'a': 'A', 'b': 'B'}
for key in x.keys():
    print(key)

使用for values in dict.values()遍历字典的值。

x = {'a': 'A', 'b': 'B'}
for values in x.values():
    print(values)

使用for item in dict.items()遍历字典的键值对

x = {'a': 'A', 'b': 'B'}
for item in x.items():
    key = item[0]
    value = item[1]
    print('%s:%s' % (key, value))

字典的item()方法返回字典中所有的键值对item，键值对item是一个元组(第0项是键，第1项是值)。
使用for key,value in dict.items()遍历字典的键值对；

x = {'a': 'A', 'b': 'B'}
for key, value in x.items():
	print('%s,%s' % (key, value))

7.集合
集合与列表的区别。
集合是一个无序的，不重复的序列，集合中所有的元素放在{}中间，并用逗号分开。

x = {1, 1, 2, 3}
print(x)

列表是有序的，提供了索引操作，集合是无序的，没有索引操作。

x = {1, 2, 3}
print(x[0])

运行后抛出异常TypeError: 'set' object is not subscriptable 。
常见运算操作。
使用运算符|合并两个集合。

x = {1, 2} | {3, 4}
print(x)

运算符-从集合中删除元素。

x = {1, 2, 3, 4} - {3, 4}
print(x)

通过关键字in检查集合中是否包含指定元素。

x1 = 'a' in {'a', 'b', 'c'}
x2 = 'd' in {'a', 'b', 'c'}
print(x1)
print(x2)

常见函数
len(set)函数获取集合的长度。

print(len({1, 2, 3})

max(set)获取集合中最大的元素。

print(max({1, 2}))

min(set)获取集合中最小的元素。

print(min({1, 2}))

常见方法
add(item)方法向集合中新增一个元素item。

x = {1, 2, 3}
x.add(4)
print(x)

remove(item)方法从集合中删除指定元素的item。

x = {'a', 'b', 'c'}
x.remove('a')
print(x)

clear()方法移除集合中的所有元素。

x = {1, 2, 3, 4}
x.clear()
print(x)

union()方法返回两个集合的并集。

x = {1, 2, 3}
y = {4, 5, 6}
z = x.union(y)
print(z)

intersection()方法返回两个集合的交集。

x = {1, 2, 3, 4}
y = {2, 3, 4, 5}
z = x.intersection(y)
print(z)

issubset()方法判断集合是否为子集。

x = {1, 2, 3}
y = {1, 2}
print(y.issubset(x))

x是y的子集。
issuperset()方法判断指定集合是否为超集。

x = {1, 2, 3}
y = {1, 2}
x.superset(y)

x是y的超集。
总结：
1.python的基本运行原理。
2.python的数据类型。