知识图谱

搭建环境

安装Python:Download Python | Python.org

安装PyCharm:Download PyCharm: The Python IDE for data science and web development by JetBrains

注意:专业版本是收费的,新手小白使用社区版(community)即可

创建第一个项目:

一些PyCharm的设置(也适用于其他JetBrains的产品,例如:IDEA,Clion)

设置背景 (可以让你敲代码的时候心情更好哈哈哈哈)

设置字体大小

同样也是在设置里面:找到编辑器—字体,就可以设置字体大小了

第一个Python程序

print("hello")

右击鼠标,再点击运行即可;或者是 快捷键Ctrl+Shift+F10

变量和类型

首先Python是一种动态类型语言,动态类型语言就是在运行时才会去检查数据类型的语言,相对的静态类型语言是在编译时就会去检查数据类型,例如:C++/Java就是静态类型语言

简单来说就是:动态类型语言的变量会随着赋值对象类型的改变而发生改变

整数类型

int

a = 10
print(type(a))

输出为<class 'int'>

PS: 和C++/Java语言不同,在Python中的int类型数据范围是无穷的,理论上只要内存足够大就可以存储无限大的数字

浮点数类型

float

a = 3.14
print(type(a))

输出为<class 'float'>

在Python中是没有double类型的,但是Python中的float其实就相对于C++/Java中的double

布尔类型

bool

a = True
print(type(a))

输出为<class 'bool'>

布尔类型只有两种取值: True和False

字符串类型

str

a = 'hello'
print(type(a))

输出为<class 'str'>

在Python中,由于没有字符类型,因此表示字符串时,使用单引号或双引号都是可以的

Python是动态类型语言

a=10
print(type(a))

a=3.14
print(type(a))

a=True
print(type(a))

a = 'hello'
print(type(a))

输出结果为:

<class 'int'>
<class 'float'>
<class 'bool'>
<class 'str'>

a的类型随着赋值对象的不同而发生改变

注释

单行注释

# 这是一行注释

多行注释(文档注释)

'''
这是一行注释
这是又一行注释
'''

输入输出

输入

关键字:input

a = input("请输入一个数字")

注意:input函数返回的数据类型是str,如果要得到数字,需要进行数据转换

a = input("请输入一个数字")
print(type(a))
a=int(a)
print(type(a))

输出为:

请输入一个数字1
<class 'str'>
<class 'int'>

输出

关键字:print

a = 10
b = True
c = "hello"
d = 3.14
print(a)
print(b)
print(c)
print(d)

输出:

10
True
hello
3.14

f-string格式化输出 (类似于C语言中的printf)

a = 10
print(f"a={a}")

运算符

算术运算符

+ - * / %不做赘述,与平常生活中的运算方式无异

** 乘方运算,同时也可以开方

print(2 ** 2)
print(9 ** 0.5)

输出为:

4
3.0

// 取整除法(地板除法)

在Python中的除法 / 结果是小数,而大多数语言的除法结果仍然是一个整数

print(5 / 2)
print(5 // 2)

输出为:

2.5
2

关系运算符

==判断相等

<=小于等于

>=大于等于

注意:对浮点数判断是否相等的时候不能够使用== 因为小数在计算机中总是不能够精确的存储

例如:

print(0.1 + 0.2 == 0.3)

输出为:

False

对于小数判断是否相等,应该使用以下代码

print(-0.000001 < (0.1 + 0.2) - 0.3 < 0.000001)

输出为:

True

逻辑运算符

and or not 分别对应C++中的&& || !

条件判断

在Python中只有一种条件判断:

if 条件:
	执行代码
elif:
	执行代码
else:
	执行代码

与C++/Java不同:Python没有用{}来表示代码块,而是采用缩进的方式

不当的缩进会导致代码bug

例题:判断一个数是不是偶数

a = 10
if a % 2 == 0:
    print("偶数")
else:
    print("奇数")

空语句:pass

在Python语法中,每一个条件判断都需要对应一个缩进,也就是执行代码块,当什么都不需要执行的时候,需要加上pass

循环语句

while 条件成立:
	执行代码

例题:计算1-100的和

i = 0
sum = 0
while i <= 100:
    sum += i
    i += 1
print(sum)

注意:i 作为循环变量需要自增,否则死循环; 同时Python并不支持++/–的操作,自增只能使用 i+=1

for 变量 in 可迭代对象
	执行代码

例题:计算1-100的和

sum = 0
for i in range(1, 101):
    sum += i
print(sum)

其中range所表示的是一个左闭右开的数据范围; 默认步长为 1

break跳出循环

continue跳过本次循环

函数

def 函数名(参数列表):
	执行代码

例题:计算从0-n的和

def getSum(n):
    sum = 0
    for i in range(0, n + 1):
        sum += i
    return sum

print(getSum(100))

输出为:

5050

参数默认值

类似于C++中的缺省参数

def getSum(a, b, c=10):
    return a + b + c

print(getSum(1, 2, 3))
print(getSum(1, 2))

其中对于第三个参数可以传也可以不传,其默认值为10

默认参数的使用规则:

1. 默认参数可以有多个
2. 默认参数必须在参数列表的最后面

关键字参数

def getSum(a, b):
    return a + b

print(getSum(b=1, a=10))

通过指定形参来传参,可以调换参数的顺序

函数返回多值

def getPoint():
    x = 10
    y = 20
    return x, y

可以返回多个值,这是C++/Java所没有的功能

其底层是将这些返回值放到一个元组中,返回类型为元组

如果我们只需要接收其中部分的返回值,可以使用_进行忽略

def getPoint():
    x = 10
    y = 20
    return x, y

_, b = getPoint()

三大常用的集合类

列表

创建

a = []
b = list()

以上两种方式都是创建一个空列表

a = [1, 2, 3, 4, 5]
b = [0.125, "hello", True, 0]

创建列表并且初始化

值得注意的是:

Python中的列表和元组类似于C++/Java 中的数组概念,但是和数组最大的区别在于—列表和元组的元素可以是不同类型的

增加元素

a.append(90)

使用append方法在列表末尾追加元素

a.insert(3,"sun")

使用insert方法在指定下标处添加指定内容,前一个参数是下标,后一个是添加内容

删除元素

a.pop()

使用pop方法删除列表末尾元素

a.pop(3)

使用pop(index) 删除指定下标的元素,上面是删除列表a中下标为3的元素

a.remove(4)

使用remove(elem)方法删除指定内容的元素,上面是删除列表a中值为4的元素

查找元素

in not in

a = [1, 2, 3, 4, 5]
print(1 in a)
print(0 in a)
print(1 not in a)
print(0 not in a)

返回值为布尔类型

输出为:

True
False
False
True

index查找下标

• 存在—返回元素下标

• 不存在—抛出异常,不会返回-1;因为-1在Python中是一个合法的下标,表示倒数第一个元素

  查找元素4(存在)

a = [1, 2, 3, 4, 5]
print(a.index(4))

​ 查找元素0(不存在)

修改元素

a = [1, 2, 3, 4, 5]
a[0] = 100
a[3] = 300

直接使用下标访问即可,但是注意下标不能越界!!

遍历列表

a = [1, 2, 3, 4, 5]

# 第一种方式
for elem in a:
    print(elem)
# 第二种方式 通过下标访问
i = 0
for i in range(0, len(a)):
    print(a[i])
# 第三种 while下标访问
i = 0
while i < len(a):
    print(a[i])
    i += 1

切片操作✨

切片操作是在Python中比较重要的操作
它可以较快的获取到指定的元素

[起始位置:结束位置:步长]

• 默认起始位置为0
• 默认结束位置为len(列表)-1
• 默认步长为1

a = [1, 2, 3, 4, 5]

截取2~4

print(a[1:4:])

截取下标为偶数的元素

print(a[0::2])

倒叙输出

print(a[::-1])

拼接列表

a = [1, 2, 3, 4, 5]
b = ["hello", True, 100]

将a b进行拼接

# 方式1
a += b

# 方式2
a.extend(b)

元组

创建

a = ()
b = tuple()

以上都是创建一个空元组

a = (1, 3.14, False, "hello")

创建元组并且初始化

元组vs列表

二者很相似,基本的操作可以参照上面的列表

但是列表是可变的,而元组是不可变的

也就是说:元组不能够进行修改删除这样的操作,只能够对元组进行读操作

元组的优势

1. 可哈希:因为元组是不可变的,所以是可哈希的;在Python中经典的不可哈希的对象—列表以及字典
2. 安全:由于元组是不可变的,所以不需要担心数据在处理过程中发生改变

字典

字典是一种存储"键值对"的集合类

key必须是Python中可哈希的对象类型,例如:列表和字典就不可以作为key

value的类型随意

创建

a = {}
b = dict()

以上都是创建两个空字典

a = {
    'id': 10,
    'name': 'Mike',
    'sex': 'man'
}

创建字典并且初始化

增加元素/修改元素

a['score'] = 100
a['id'] = 12

字典变量名[key]=value

• 如果key存在字典中,则为修改key对应的value
• 如果key不存在,则为增加元素

删除元素

a.pop('id')

字典变量名.pop(key)

pop方法删除key所对应的键值对

查找元素

print('id' in a)
print(a['id'])

使用in/not in进行查找,亦或者通过下标访问,如果不存在将抛出异常

遍历字典

for elem in a:
    print(elem, a[elem])

其中elem对应a中的key, a[elem]则是通过下标访问的形式得到的value

字典的常用方法

a.keys() # 获取到所有的key
a.values() #获取到所有的value
a.items() # 获取到所有的键值对(包括key和value)

如果我的文章对你有帮助的话,欢迎点赞收藏哦😘😘
同时如果文章中有错误的话,也欢迎各位大佬指出😁