【深度学习】Python 快速入门

1. IPython和Jupyter笔记本

Jupyter notebook 是一种 Web 应用，它能让用户将说明文本、数学方程、代码和可视化内容全部组合到一个易于共享的文档中，非常方便研究和教学，让编写、阅读变得一目了然。Jupyter notebook特别适合做科学计算、数据处理，其用途可以包括数据清理和探索、可视化、机器学习和大数据分析。其具有以下特点：

• 编程时具有语法高亮、缩进、tab补全的功能；
• 可直接通过浏览器运行代码，同时在代码块下方展示运行结果；
• 以富媒体格式展示计算结果，富媒体格式包括：HTML，LaTeX，PNG，SVG等；
• 对代码编写说明文档或语句时，支持Markdown语法；
• 支持使用LaTeX编写数学性说明。

1.1 Jupyter 安装

安装Jupyter最简单的方法就是使用 Anaconda，其发行版附带了 Jupyter Notebook。在 conda 环境下安装 Jupyter Notebook 可以使用：

conda install jupyter

当然，也可以通过 pip 来安装：

pip install jupyter

安装后便可在终端中输入以下命令启动：

# jupyter notebook

或者
# jupyter-notebook

1.2 Jupyter 常用操作

2. 变量

用于表示某物或值的名称称为变量。在Python中，可以声明变量并为其赋值，如下所示：

x = 2
y = 5
xy = 'Hey'
print(x+y, xy)
#输出：7 Hey

多变量可以被赋予相同的名字。

x = y = 1
print(x,y)
#输出：1 1

3.1 算术运算符

3.2 关系运算符

3.3 位运算符

4. 内置函数

4.1 数值函数

round( ) 函数将输入值四舍五入到指定的位数或最接近的整数。

print(round(5.6231))
print(round(4.55892, 2))
# 6
# 4.56

complex( ) 被用来定义一个复数 abs( ) 输出相同的绝对值。

c =complex('5+2j')
print(abs(c))
# 5.385164807134504

divmod(x,y) 输出商和余数在元组的格式(商，余数)。

divmod(9,2)
# (4, 1)

如果第一个参数是该类的实例，isinstance( ) 则返回True。还可以同时检查多个类。

print(isinstance(1, int))
print(isinstance(1.0,int))
print(isinstance(1.0,(int,float)))
# True
# False
# True

pow(x,y,z) 可以被用来找到幂函数 x y x^y x y 也可以找到第三个指定数字的mod值，即:( x y x^y x y % z)。

print(pow(3,3))
print(pow(3,3,5))
# 27
# 2

range( ) 函数输出指定范围的整数。它还可以用于通过指定特定范围内的两个数字之间的差来生成一个序列，元素以列表的形式返回。

print(list(range(3)))
print(list(range(2,9)))
print(list(range(2,27,8)))
# [0, 1, 2]
# [2, 3, 4, 5, 6, 7, 8]
# [2, 10, 18, 26]

4.2 用户输入

input( ) 接受输入并以字符串的形式保存。

abc = input("Type something here and it will be stored in variable abc \t")
# Type something here and it will be stored in variable abc 	此处我们键入10

查看输入的10的类型：

type(abc)
# str 字符串类型

4.3 打印输出

print("Hello World")
# Hello World

在Python中，单引号、双引号和三引号用于表示字符串：

• 大部分情况下单引号用于声明一个字符；
• 声明一行时使用双引号，声明段落/多行时使用三引号。

print('Hey')
a = 'line1\
line2\
\
'
print(a)

#Hey
#line1line2

print("""My name is Rajath Kumar M.P.

I love Python.""")

# My name is Rajath Kumar M.P.
# 
# I love Python.

字符串连接是两个字符串的“加法”。注意，在连接时，字符串之间不会有空格：

print('Hello' + string1 + string2)
# HelloWorld!

4.4 格式化输出

- %s -> string
- %d -> Integer
- %f -> Float
- %o -> Octal
- %x -> Hexadecimal
- %e -> exponential

用于print函数本身内部的转换：

print("Actual Number = %d" % 18)
print("Float of the number = %f" % 18)
print("Octal equivalent of the number = %o" % 18)
print("Hexadecimal equivalent of the number = %x" % 18)
print("Exponential equivalent of the number = %e" % 18)

# Actual Number = 18
# Float of the number = 18.000000
# Octal equivalent of the number = 22
# Hexadecimal equivalent of the number = 12
# Exponential equivalent of the number = 1.800000e+01

当引用多个变量时使用圆括号：

print("Hello %s %s" % (string1,string2))
# Hello World !

5 数据结构

5.1 列表

列表是最常用的数据结构。可以把它看作用方括号括起来的数据序列，数据之间用逗号分隔。这些数据都可以通过调用其索引值来访问。list的声明只需将变量等同于[ ]或list即可。

a = []
print(type(a))
# 

可以直接将数据序列分配给列表x，如下所示：

x = ['apple', 'orange', 'peach']
print(x)
# ['apple', 'orange', 'peach']

5.1.1 索引

在Python中，索引从0开始。因此，现在包含两个元素的列表x的apple索引值为0,orange索引值为1。

x[0]
# 'apple'

索引也可以按照相反的顺序进行。这是最后一个可以被首先访问的元素。这里，索引从-1开始。因此，索引-1对应是橙色，索引-2对应的是苹果。

x[-1]
# 'peach'

声明两个列表x和y每一个包含自己的数据。现在，这两个列表可以再一次被放入另一个也具有自己的数据的列表z中。列表中的这个列表被称为嵌套列表，这就是数组的声明方式，我们将在后面看到。这是和很多其他计算机语言不同的地方，不要求列表的元素是相同类型，因此编程的时候会非常方便，这也是为什么Python对人类比较友好。

x = ['apple', 'orange', 'peach']
y = ['carrot','potato']
z  = [x,y, 'Test']
print(z)
# [['apple', 'orange', 'peach'], ['carrot', 'potato'], 'Test']

z[0][1]
# 'orange'

如何获得嵌套列表中的某个元素？让我们在上述嵌套列表中获得数据’apple’为例：

• 首先在索引为0处，有一个列表 ['apple','orange'] 而在索引为1处有另外一个列表 ['carrot','potato'] ;
• 因此z[0] 应该给我们第一个包含’apple’的列表。

z1 = z[0]
print(z1)
# ['apple', 'orange', 'peach']

现在观察z1并不是一个嵌套列表，因此为了获得’apple’，z1的索引应该为0。

z1[0]
# 'apple'

在python中，你可以通过每次并排写索引值来访问“apple”，而不是像上面那样做：

z[0][0]
# 'apple'

5.1.2 切片

索引只限于访问单个元素，而切片则是访问列表内的一系列数据。换句话说，切片返回的是一个列表。

切片是通过定义切片列表中需要的父列表中的第一个元素和最后一个元素（不包含，即左闭右开）的索引值来完成的。它被写成 parentlist[a: b] ，其中a,b是父列表的索引值。如果a或b未定义，则认为该索引值是a未定义时的第一个值，以及b未定义时的最后一个值。

num = [2,3,2,3,4,5,6,7,8,9]
print(num[1:4])
print(num[0:])
print(num[:])
print(num)

# [3, 2, 3]
# [2, 3, 2, 3, 4, 5, 6, 7, 8, 9]
# [2, 3, 2, 3, 4, 5, 6, 7, 8, 9]
# [2, 3, 2, 3, 4, 5, 6, 7, 8, 9]

print(num[0:4])
print(num[4:])

# [2, 3, 2, 3]
# [4, 5, 6, 7, 8, 9]

还可以使用固定长度或步长对父列表进行切片：

num[:9:3]
# [2, 3, 6]

5.1.3 列表的内置函数

列表的长度或者列表中元素的数量：

len(num)

min( ) 和 max( ) 给出列表中的最大值和最小值：

min(num)
max(num)

列表拼接：

[1,2,3] + [5,4,7]
# [1, 2, 3, 5, 4, 7]

判断列表中是否存在特定的元素：

names = ['Earth','Air','Fire','Water']
'Fir' in names
# False
'Fire' in names
# True
'fire' in names
# False

字符串转化为列表：

list('hello')
# ['h', 'e', 'l', 'l', 'o']

append( ) 被用来在列表的最后添加一个元素：

lst = [1,1,4,8,7]
lst.append(1)
print(lst)
# [1, 1, 4, 8, 7, 1]

count( ) 用于计算列表中出现的特定元素的数量：

lst.count(1)
# 3

append( ) 函数也可以被用来在末尾添加一整个列表：

lst1 = [5,4,2,8]
lst.append(lst1)
print(lst)
# [1, 1, 4, 8, 7, 1, [5, 4, 2, 8]]

列表拼接：

lst.extend(lst1)
print(lst)
[1, 1, 4, 8, 7, 1, [5, 4, 2, 8], 5, 4, 2, 8]

index( ) 被用来找到一个特殊元素的索引值，注意如果有许多个元素具有相同的值那么元素第一个索引值会被返回：

lst.index(1)
# 0

insert(x,y) 用于在指定的索引值x处插入元素y。append( ) 函数使得它只能插在最后。

lst.insert(5, 'name')
print(lst)
# [1, 1, 4, 8, 7, 'name', 1, [5, 4, 2, 8], 5, 4, 2, 8]

pop( ) 函数返回列表中的最后一个元素。这类似于堆栈的操作。因此，说列表可以作为堆栈使用是正确的。

lst.pop()

可以指定索引值来弹出与该索引值对应的元素：

lst.pop(2)
print(lst)
# [1, 1, 8, 7, 'Python', 1, [5, 4, 2, 8], 5, 4, 2]

使用remove() 函数通过值来删除元素：

print(lst)
# [1, 1, 8, 7, 'Python', 1, 5]
lst.remove('Python')
print(lst)
# [1, 1, 8, 7, 1, 5]

reverse() 函数反转列表中出现的所有元素：

print(lst)
# [1, 1, 5]
lst.reverse()
print(lst)
# [5, 1, 1]

sort( ) 去按升序排列元素：

lst = [1, 4, 8, 8, 10]
lst.sort()
print(lst)
# [1, 4, 8, 8, 10]

对于降序，因为默认情况下反向条件为False。因此，将其更改为True将按降序排列元素。

lst.sort(reverse=True)
print(lst)
# [10, 8, 8, 4, 1]

大多数新的python程序员都会犯这个错误，即对象的赋值和拷贝的差异。考虑以下的例子：

lista= [2,1,4,3]
listb = lista # 对象赋值
print(listb)
# [2, 1, 4, 3]

这里，我们声明了一个列表，lista = [2,1,4,3]。通过赋值将该列表复制到listb，并复制该列表。现在我们对lista执行一些随机操作。

lista.pop()
print(lista)
# [2, 1, 4]
lista.append(9)
print(lista)
# [2, 1, 4, 9]
print(listb)
# [2, 1, 4, 9]

虽然没有对listb执行任何操作，但它也发生了变化。这是因为您将lista、listb指向相同的内存空间。

复制列表：

lista = [2,1,4,3]
listb = lista[:]
print(listb)
# [2, 1, 4, 3]

lista.pop()
print(lista)
# [2, 1, 4]
lista.append(9)
print(lista)
# [2, 1, 4, 9]

print(listb)
# [2, 1, 4, 3]

5.2 元组

元组与列表相似，但唯一大的区别是列表中的元素可以更改，而元组中的元素不能更改。

定义元组：

tup = ()
tup2 = tuple()

声明元组时可以分配值。它接受一个列表作为输入并将其转换为元组，或者接受一个字符串并将其转换为元组：

tup3 = tuple([1,2,3])
print(tup3)
# (1, 2, 3)
tup4 = tuple('Hello')
print(tup4)
# ('H', 'e', 'l', 'l', 'o')

元组遵循与列表相同的索引和切片：

print(tup3[1])
# 2
tup5 = tup4[:3]
print(tup5)
# ('H', 'e', 'l')

5.2.1 将一个元组映射到另一个元组

(a,b,c)= ('alpha','beta','gamma')
print(a,b,c)
# alpha beta gamma

5.2.2 元组内置函数

count() 函数计算元组中存在的指定元素的数量：

d = tuple('RajathKumarMP')
print(d)
# ('R', 'a', 'j', 'a', 't', 'h', 'K', 'u', 'm', 'a', 'r', 'M', 'P')
d.count('a')
# 3

index() 函数返回指定元素的索引。如果元素数量大于1，则返回该指定元素的第一个元素的索引：

d.index('a')
# 1

5.3 集合

集合主要用于消除序列/列表中的重复数字。它还用于执行一些标准的集合操作。

set被声明为set()，它将初始化一个空集。set([sequence])也可以被执行来声明一个包含元素的集合：

set1 = set()
set0 = set([1,2,2,3,3,4])
print(set0)
# {1, 2, 3, 4}

set1 = set((1,2,2,3,3,4))
print(set1)
# {1, 2, 3, 4}

重复两次的元素2,3只会出现一次。因此在一个集合中，每个元素都是不同的。

5.3.1 内置函数

set1 = set([1,2,3])
set2 = set([2,3,4,5])

union( ) 函数返回一个并集合，该集合包含两个集合的所有元素，但是没有重复：

set1.union(set2)
# {1, 2, 3, 4, 5}

add() 将向集合中添加一个特定的元素：

print(set1)
# {0, 1, 2, 3}
set1.add(0)
print(set1)
# {0, 1, 2, 3}

intersection( ) 函数输出一个交集合，该集合包含两个集合中的所有元素：

set1.intersection(set2)
# {2, 3}

difference( ) 函数输出一个集合，其中包含在set1中而不在set2中的元素：

print(set1)
# {0, 1, 2, 3}
print(set2)
# {2, 3, 4, 5}
set1.difference(set2)
# {0, 1}

remove( ) 函数从集合中删除指定值的元素：

set1.remove(2)
print(set1)
# {1, 3}

clear( ) 用于清除所有元素并将其设置为空集:

set1.clear()
print(set1)
# set()

5.4 字符串

字符串是基于文本的有序数据，用单/双/三重引号括起来表示。

String0 = 'Taj Mahal is beautiful'
String1 = "Taj Mahal is beautiful"
String2 = '''Taj Mahal
is
beautiful'''

字符串索引和分段类似于前面详细解释过的列表：

print(String0[4])
# M
print(String0[4:])
# Mahal is beautiful
print(String0[-1])
# 1

5.4.1 内置函数

find( ) 函数返回要在字符串中找到的给定数据的索引值，返回的索引值是输入数据中第一个元素的索引。如果没有找到它，它返回 -1。请注意不要将返回的-1与反向索引值混淆：

print(String0)
# Taj Mahal is beautiful
print(String0.find('al'))
# 7
print(String0.find('am'))
# -1

capitalize( ) 用于将字符串中的第一个元素大写：

String3 = 'observe the first letter in this sentence. can you change this sentence'
print(String3.capitalize())
# Observe the first letter in this sentence. can you change this sentence

center( ) 用于通过指定字段宽度将字符串居中对齐：

String0.center(70)
# '                        Taj Mahal is beautiful                        '

zfill( ) 通过指定字段宽度来填充零：

String0.zfill(30)
# '00000000Taj Mahal is beautiful'

index( ) 和 find( ) 函数的工作方式相同，唯一的区别在于 find( ) 返回’-1’，当输入元素在字符串中没有找到，但是index( ) 函数会抛出一个ValueError。

print(String0.index('Taj'))
# 0
print(String0.index('Mahal',0))
# 4
print(String0.index('Mahal',10,20))

endswith( ) 函数用于检查给定字符串是否以作为输入的特定字符结尾：

print(String0.endswith('y'))
# False
# 指定开始和停止索引值。指定开始和停止索引值。
print(String0.endswith('M',0,5))
# True

count( ) 函数计算给定字符串中的字符数。也可以指定开始和停止索引或将其留空：

print(String0.count('a',0))
# 4
print(String0.count('a',5,10))
# 2

join( ) 函数在输入字符串的元素之间添加一个字符：

'a'.join('123')
# '1a2a3'

'123’是输入字符串而字符’a’被添加在每一个元素之间。

join( ) 函数也可以被用来将列表转化为字符串：

a = list(String0)
print(a)
# ['T', 'a', 'j', ' ', 'M', 'a', 'h', 'a', 'l', ' ', 'i', 's', ' ', 'b', 'e', 'a', 'u', 't', 'i', 'f', 'u', 'l']
b = ''.join(a)
print(b)
# Taj Mahal is beautiful

split( ) 函数被用来将一个字符串转化为列表：

c = " /i/s/ /b/e/a/u/t/i/f/u/l"
d = c.split('/')
print(d)
# [' ', 'i', 's', ' ', 'b', 'e', 'a', 'u', 't', 'i', 'f', 'u', 'l']

lower( ) 将任何大写字母转换为小写字母：

print(String0)
# Taj Mahal is beautiful
print(String0.lower())
# taj mahal is beautiful

upper( ) 将任何小写字母转换为大写字母：

String0.upper()
# 'TAJ MAHAL IS BEAUTIFUL'

replace( ) 函数将该元素替换为另一个元素：

String0.replace('Taj Mahal','Bengaluru')
# 'Bengaluru is beautiful'

strip( ) 函数用于从右端和左端删除不需要的元素：

f = '    hello      '
f.strip() # 'hello'

lstrip( ) 和 rstrip( ) 函数具有与strip函数相同的功能，但唯一的区别是lstrip() 只删除左边的内容，而rstrip() 只删除右边的内容：

f = '   ***----hello---*******     '
print(f.lstrip(' *'))
----hello---*******   
print(f.rstrip(' *'))
   ***----hello---

5.5 字典

定义词典：

d0 = {
 }
d1 = dict()

d0['One'] = 1
d0['OneTwo'] = 12 
print(d0)
{
 'One': 1, 'OneTwo': 12}

zip( ) 可以合并多个列表成一个元组，配和dict()使用可以声明字典：

names = ['One', 'Two', 'Three', 'Four', 'Five']
numbers = [1, 2, 3, 4, 5]
d2 = zip(names,numbers)
print(dict(d2))
{
 'One': 1, 'Two': 2, 'Three': 3, 'Four': 4, 'Five': 5}

5.5.1 内置函数

clear( ) 清空字典：

a1 = {
 1:10, 2:20}
a1.clear()
print(a1)
# {}

values( ) 返回了一个包含字典中所有赋值的列表：

a1.values()
# dict_values([1, 2, 3, 4, 5])

keys( ) 返回包含赋值的所有索引或键：

a1.keys()
# dict_keys(['One', 'Two', 'Three', 'Four', 'Five'])

items() 返回一个列表，但是字典中的每个元素都是列表中的一个元组， 在这里插入代码片 与使用zip函数得到的结果相同：

a1.items()

for (k,v) in a1.items():
    print("[%6s] %d" % (k, v))

pop() 函数用于删除特定的元素，并且这个删除的元素可以被分配给一个新的变量：

a2 = a1.pop('One')

到此结束，感兴趣的可以点击下方名片了解哦~