python基本语法总结

python 是一门在数据科学领域应用十分广泛的编程语言，它简单，优美的代码结构让越来越多的数据玩家选择将其作为首选编程语言。python 拥有众多开源的代码库，并且还在源源不断的增加，开源并且丰富的代码库能够极大的节省使用者在编程语言上的精力，使其能够更加专注的考虑程序背后的逻辑。

网上有太多关于python的学习教程，找一个讲解通俗易懂的教程学习一遍就已经足够了，大可不必花费太多时间在基础语法的学习上。如果你已经学习过python语言，相信能够明白这个道理，如果你将要开始学习python语言，那么请相信我，用7到10天的时间学习基础语法就已经足够了。

我们不想做重复的劳动，对每一个知识点进行细致的讲解，我们只想将我们的学习总结分享出来，供大家在学习完基础教程之后进行参考，帮助大家对知识点进行梳理。

三点注意

1. 在python中，我们使用缩进来代表代码的层级结构。缩进一般用4个字符，按一次Tab键即可。
2. python中对于大小写是敏感的。不能够混淆使用。
3. 必须在英文状态下输入字符！！！

1. 输入和输出

1.1 输入函数input()

允许用户输入一个字符串，并且保存在一个变量里。eg:

 name = input()

当输入上述命令后，python就在等着用户输入内容了，这时候，不管用户输入什么内容，都会将输入的内容存储在一个名称为name的变量中。

另外，input()的括号中，还可以输入提示字符，这是一种对用户非常友好的设计。例如：

name = input("please enter a name:")

当用户将上述语句输入后，屏幕上会出现 " please enter a name:"的提示语句，这时候用户可以方便的根据提示语句输入内容，输入的内容会保存在变量 name中。

另外，需要注意的是，input()函数返回的是字符串类型(str),如果期望输入的值为整数类型，则需要使用以下方法进行转换：

a = int(input("please enter a number:"))

这样就可以将输入值强行转化为整数类型的值。

1.2 输出函数print()

1.2.1 最简单的输出方式就是直接在print()得括号中写入一串字符串，print函数可以直接输出。eg:

>>> print("Hello World!")
Hello World!

1.2.2 当用户需要输入多个字符串时，中间可以用逗号隔开(英文状态下的逗号)，这时在输出过程中，逗号会变为空格将逗号前后的字符分隔开,因此在字符串中不必特意输入一个空格。eg:

>>> print("Welcome","to","datakuibu")
Welcome to datakuibu

1.2.3 对于数字型变量：print函数可以直接输入，也可以输出计算结果。不用添加双引号或者单引号。eg:

>>> print(521)
521
>>>print(1+520)
521

1.2.4 当输出内容中既包括字符串也包括数字型变量时，将两者中间用逗号（英文状态）隔开，并且字符串加上双引号（单引号），而数字型变量不需要加引号。eg:

>>> print("1+520 =",1+520)
1+520 = 521

注意：可以发现等号前后各有一个空格，等号前面的空格是字符串中的空格字符，等号后边的空格是由print()函数中的逗号生成的。

1. 结合输入和输出函数

>>> name=input("please enter a name:")
datakuibu
>>> print("good day",name)
good day datakuibu

2. 数据类型

1. 整数

python可以处理任意大小的整数，包括正整数，0，负整数。整数的表示方式和数学上是一样的，eg:1, 13, 0, -15.

2. 浮点数

浮点数就是我们平时所说的小数。因此浮点数可以用数学中的写法，eg: 1.23, 2.34, -4.23.但是当小数点后位数非常多时，就必须要用科学计数法来表示。eg: 5.23*10^9,需要表示为5.23e9 或者5.23E9。可以发现e(E)代表了10。也可以表示为52.3e8 或 523e7，也就是说小数点的位置时可以移动的，这也就是浮点数名称的由来。当指数变为负数时，表示方式依然是一样的。eg:0.0000023 可以表示为 2.3e-6.

3. 字符串

字符串是用单引号(’’)或者双引号("")引起来的文字。eg:"hello ", ‘hahahahhaha’, 单引号和双引号都可以用来表示字符串，两者没有区别，但是不能够混用。eg:"hello’,'hhahahah"这种方式是错误的。

当字符串中出现了单引号或者双引号时，可以使用如下方法。“I’m datakuibu" 或者’I love “datakuibu” '。可以发现，当字符串内部出现单引号（双引号）时，就用双引号（单引号）来表示字符串。

但是，还有一个问题，万一字符串中既有单引号又有双引号可怎么办？这时候需要引入转义字符（\）。

例如我们要输入下边这句话，可以先把要输入的那内容写好，先不用管引号和转义字符的问题。

(1) I'm "idata"

​ 接下来，我们为字符串中出现的每个引号添加转义字符，方法很简单，就是在每个引号前面添加 转义字符 \ 。最后再在字符串开头和结尾添加上一对单引号或者双引号。

(2) I\'m \"idata\"
(3) 'I\'m \"idata\"'

字符串的方法

1.大小写互换。swapcase.

>>> s="I aM a STUdeNT!"
>>> s.swapcase()#大小写进行转换
'i Am A stuDEnt!'
s.upper()#全部大写
s.lower()#全部小写

2.字符串的分割与连接。s.split(“分隔符”) “连接符".join(要连接的list )

从下边的例子中可以看出：

i：第四行到第九行可以看出，字符串是不可变对象，内容不可以改变。

ii:字符串被分割后形成一个list，list 经过连接后形成一个string。

 b=s.split(" ")
>>> b
['I', 'aM', 'a', 'STUdeNT!']
>>> s
'I aM a STUdeNT!'
>>> s.split(" ")
['I', 'aM', 'a', 'STUdeNT!']
>>> s
'I aM a STUdeNT!'
>>> "-".join(b)#把列表连成一个字符串
'I-aM-a-STUdeNT!'

3.改变字符串中特定位置上的字符。

>>> string = "abracadabra"
>>> print string[5]
a
>>> string[5] = 'k' 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
#解法一：
>>> string = "abracadabra"
>>> l = list(string)
>>> l[5] = 'k'
>>> string = ''.join(l)
>>> print string
abrackdabra
#解法二：
>>> string = string[:5] + "k" + string[6:]
>>> print string
abrackdabra

从第10行可以看出可以通过list方法将字符串转换为list。

第16行就包含了字符串的切片工作。

字符串的切片工作：字符串中的位置标号从0开始。

>>> string = 'ABCDEFG'
#取出第0个位置的元素
>>> string[0]
'A'
#取出字符串前3个位置的字符
>>> string[:3]
'ABC'
#取出字符串第4个位置向后所有的字符
>>> string[4:]
'DEFG'
#字符串中间隔一个字符取出
>>> string[::2]
'ACEG'
#取出最后一个位置的元素
>>> string[-1]
'G'

4.布尔值和布尔运算符

布尔值只有两种：True和False。布尔运算符有三个：and, or, not.

3. 变量

变量在程序中需要用一个变量名来表示，为变量命名时，可以用数字，字母和下划线。但是变量名只能以字幕或下划线开头，不能以数字开头。

正确变量名：a, sfg, ag_fg, _seg

错误变量名：32sa, kl%s, 9sa_dsf

注意：python是区分大小写的（case-sensitive)。abc和Abc 代表不同的变量。

给变量赋值时用 ”=" 。"=“和”=="是不同的。前者是赋值符号。后者是等号。

4. 数据结构

4.1 list操作

list 是python语言的一种数据类型，列表是一个有序的集合，可以对列表内的元素进行增加，删除和修改。list是可变对象。

>>> food=["apple","pear","carrot"]
>>> food
['apple', 'pear', 'carrot']
#进行索引，取出第1个元素
>>> food[0]
'apple'
#取出第3个元素
>>> food[2]
'carrot'
#取出倒数第一个元素
>>> food[-1]
'carrot'
#在列表后边添加一个元素
>>> food.append('banana')
>>> food
['apple', 'pear', 'carrot', 'banana']
#查看列表中元素个数
>>> len(food)
4
#在第2个位置插入一个元素
>>> food.insert(1,'orange')
>>> food
['apple', 'orange', 'pear', 'carrot', 'banana']
#在括号中为空时，默认删除最后一个元素
>>> food.pop()
'banana'
>>> food
['apple', 'orange', 'pear', 'carrot']
#括号中有数字时，删除该位置上的元素
>>> food.pop(1)
'orange'
>>> food
['apple', 'pear', 'carrot']
#对列表中那个元素进行修改
>>> food[0]='orange'
>>> food
['orange', 'pear', 'carrot']
#对列表中元素进行排序
>>> food.sort()
>>> food
['carrot', 'orange', 'pear']
#将列表中元素进行倒序输出
>>> food.reverse()
>>> food
['pear', 'orange', 'carrot']

分析以上代码，可以看出list 的基本操作：

list[index]:可以索引list 中特定位置上的元素，索引值从0开始，若是从右向左索引，则最后一位元素的索引值为[-1].

list.append()可以在list 最后添加元素。只能添加一个。

list.insert(index,value)可以在特定索引值处添加元素。

list.pop()默认删除list的最后一个元素。

list.pop(i)删除索引值为i 的元素。

若想直接修改list 中某个索引值 i 处的元素值，可以使用list[i]=value直接修改。

len(list)可以计算list 中元素的个数。

list.sort()是对list 中的元素进行排序。

list.reverse()reverse the list.

note：list 是用[]括起来表示的。

map函数：

>>> l=['1','2','3']
>>> map(int,l)
<map object at 0x02EA4FF0>
>>> print(map(int,l))
<map object at 0x0030F050>
>>> print(list(map(int,l)))
[1, 2, 3]

列表生成式 [要生成的元素 for循环 条件]

#第一种方法
>>> l=list(range(1,11))
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#第二种方法
>>> [x*x+x for x in range(1,10)]
[2, 6, 12, 20, 30, 42, 56, 72, 90]
#第三种方法（以下方法生成的是全排列）
>>> [x + y for x in range(1,10) for y in range(1,10)]
[2, 3, 4, 5, 6, 7, 8, 9, 10, 3, 4, 5, 6, 7, 8, 9, 10, 11, 4, 5, 6, 7, 8, 9, 10, 11, 12, 5, 6, 7, 8, 9, 10, 11, 12, 13, 6, 7, 8, 9, 10, 11, 12, 13, 14, 7, 8, 9, 10, 11, 12, 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15, 16, 9, 10, 11, 12, 13, 14, 15, 16, 17, 10, 11, 12, 13, 14, 15, 16, 17, 18]
#第四种方法（带条件）
>>> [x * x for x in range(10) if x%2 == 0]
[0, 4, 16, 36, 64]
#第五种方法
>>> lst=["Jack","boB","aPPle"]
>>> [s.upper() for s in lst]
['JACK', 'BOB', 'APPLE']   

list的切片工具：

>>> l=list(range(10))
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#取出前3个位置的元素
>>> l[0:3]
[0, 1, 2]
#取出第2个和第3个元素
>>> l[1:3]
[1, 2]
#将所有元素进行间隔取出
>>> l[::2]
[0, 2, 4, 6, 8]
#取出所有元素
>>> l[:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

4.2 tuple操作

tuple可list 一样，也是一种有序的数组集合，区别就是，tuple中的元素是不可变的，不能够修改，没有append，insert等方法，可以进行正常的索引来获取元素值，但是不能够进行赋值操作。tuple是不可变对象。

>>> number=(0,1,2)
>>> number
(0, 1, 2)
>>> number=()
>>> number
()
>>> number=(1)
>>> number
1
>>> number=(1,)
>>> number
(1,)
>>> number=(0,1,[2,3])
>>> number[2][0]='a'
>>> number[2][1]='b'
>>> number
(0, 1, ['a', 'b'])

分析以上代码，可以看出：

1.tuple使用()表示的。

2.当tuple只有一个元素时，必须在这个元素后边加上一个逗号。否则，python会认为这个括号时数学公式中的小括号，而不是tuple的表示符号。在输出时也带着这个逗号。

3.当tuple的元素中存在着list 时，list中的内容时可以进行修改的。

4.3 字典

dict是字典，使用key-value存储，查找速度极快。dict要用花括号括起来，key和value之间用冒号隔开，每个key-value之间用逗号隔开。查找时，根据key值查找对应的value。eg：

>>> d={"A":100,"B":90,"C":80}
>>> d["A"]
100
>>> d["E"]=60
>>> d
{'A': 100, 'B': 90, 'C': 80, 'E': 60}

1.查找时，根据key值查找对应的value。**key值必须是不可变对象（字符串，整数）。**最常用的是字符串。

2.可以通过上述方法（添加E的方法）直接向字典中添加元素。

3.一个key只能对用一个value，所以后边的value会替换前面的value。

>>> d["E"]=50
>>> d["E"]
50
>>> d["E"]=40
>>> d["E"]
40

4.可以通过in判断dict中是否存在key。

>>> "E" in d
True
>>> "F" in d
False

5.可以通过pop(key)的方法删除key，与这个key对应的value也会被删除。

 d.pop("E")
40
>>> d
{'A': 100, 'B': 90, 'C': 80}

for循环作用与dict:

>>> d={"a":1,"b":2,"c":3}
>>> for key in d:
	print(key)

a
b
c
>>> for a in d.keys():
	print(a)
a
b
c
从以上两组代码中可以看出，当需要遍历字典中的key时，d和d.keys()都可以作为遍历对象。

#当需要遍历字典中的value时，
#需要使用d.values()作为遍历对象。
>>> for value in d.values():
	print(value)
	
1
2
3
#当需要遍历字典中的key-value时，
#需要使用d.items()作为遍历对象。
>>> for a,b in d.items():
	print(a,b)
	
a 1
b 2
c 3

4.4 set

set可以看作数学上的无序和无重复元素的集合。

set的创建需要一个list，然后用小括号括起来。

>>> s=set([1,2,3])
>>> s
{1, 2, 3}

set可以通过add方法添加元素，通过remove方法移除元素。重复添加是没有意义的。可以用in来判断一个元素是否在set中。

>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.remove(4)
>>> s
{1, 2, 3}
>>> 3 in s
True

set可以进行数学上的交（&）和并（|）的运算。

>>> s1=set([1,2,3,4])
>>> s2=set([1,2,3,5])
>>> s1&s2
{1, 2, 3}
>>> s1|s2
{1, 2, 3, 4, 5}

5. 控制流

5.1 if……elif……else条件判断

if condition:
    print()
elif condition:
    execute 
elif condition:
    execute 
else:
    execute

每个if，elif，else语句后边都要有冒号。

if条件判断时从上往下执行，一旦符合某个条件，便执行该条件下边的语句，执行完后便不再执行其他条件语句，即忽略掉剩下的所有elif和else。

5.2 for循环

for循环有两种类型（个人分类）：

>>> food=['apple','banana','orange']
>>> for item in food:
	print(item)

apple
banana
orange
>>> for i in range(4):
	print(i)

0
1
2
3

5.3 while循环

只要while后边的条件能够满足，就一直执行while下面的语句，当条件不满足时，跳出while循环。

count=0
n=999
while n > 0:
    count=count+1
    n=n-3
print(count)

计算1000以内有多少个3的倍数。

6. 可变对象和不可变对象

list是可变对象。

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']

可以看出对list进行排序后，list发生了改变。

str是不可变对象。

>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'

再与下边的代码进行比较：

>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'

所以，对于不可变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

7. 函数

7.1 内置函数

python内置函数：

>>> abs(2.1)
2.1
>>> abs(-2)
2
>>> abs(-2+2j)
2.8284271247461903
>>> abs(-2+2i)
SyntaxError: invalid syntax

1.abs函数：绝对值函数，当参数为复数时，返回复数的模值。注意其中的错误示例，复数的虚部只能用j。

2.max函数、min函数：求最大值、最小值

数据类型转换函数:

>>> str(12)
'12'
>>> int("12")
12
>>> float(12.32)
12.32
>>> float("12.32")
12.32
>>> int('12.32')
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    int('12.32')
ValueError: invalid literal for int() with base 10: '12.32'
>>> int(12.32)
12
>>> bool(1)
True
>>> bool(True)
True
>>> bool("")
False

注意其中的错误示例：int函数不能够将一个字符串类型的小数转换为整数。

7.2 自定义函数

python中定义函数需要依次写出def，函数名称，括号，参数，冒号。用return语句返回。

空函数：

def empty():
    pass

空函数的作用：用来占位的，比如现在还没有想好怎么写代码，就先写一个空函数，这样程序其他部分也可以先运行起来。

def power(x,n):
    s=1
    for i in range(n):
        s=s*x
    return s 

print(power(5,2))
print(power(5,4))
返回值：
25
625

7.3 函数的参数

7.3.1 默认参数

当我们需要经常计算平方值时，可以将函数定义为power(x,n=2),这样，当计算平方值时，只需要输入一个数值即可，当想要计算高次方时，在第二个位置上输入n值即可。

def power(x,n=2):
    s=1
    for i in range(n):
        s=s*x
    return s 

print(power(5,2))
print(power(5))
print(power(5,4))

25
25
625

设置默认函数时的注意事项：

必填参数在前，默认参数在后。

默认参数必须指向不变对象。

可变参数

可变参数意味着传入函数的参数个数是可变的。

eg:计算
$$a^2+b^2+c^2+d^2+\dots \dots$$
solution1：我们将要计算的数字组成一个list或者tuple传入到函数中。

def result(parameter):
    sum=0
    for i in parameter:
        sum=sum+i*i
    return sum
函数调用
result([1,2,3])
result((1,2,3,4))

这种方法的缺点就是需要提前把要输入的数转换为一个list或者tuple。接下来采用可变参数的方法可以解决这个问题。

def result(*parameter):
    sum=0
    for i in parameter:
        sum=sum+i*i
    return sum
函数调用
result(1,2,3)
result(1,2,3,4)

在形参前面加上一个 * ，*表明它后边的参数是一个可变参数。在函数内部。参数parameter接收到的是一个tuple，就是说自动将实参中的数字转变为一个tuple传入到函数中。也可以传入0个参数。换句话说，可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

如果已经有一个list或者tuple。这时可以用下面的这种写法。将一个list或者tuple 作为可变参数传入到函数中。

>>> num=[1,2,3]
>>> result(*num)
14

*num将num中的所有元素作为可变参数传入到函数中。这是一种很常用的方法。

8. 参考

1.廖雪峰老师的python教程

第一次写博客，学习了廖老师的python教程，做些总结，有错误的地方，请大家多多指正。在此感谢廖老师的无私付出！