Python入门

基本

print()函数

• 输出可以是数字 print(1220)
• 输出可以是字符串print('candle')，字符串需要用单引号或者双引号括起来
• 输出可以直接输出操作数之间的运算结果print(12*20)

print()函数有一个内置参数end，使用print()函数时默认end='\n'，如果不想每次执行玩print()函数后换行，可以修改end的参数，比如print('*',end='')，此时参数为空字符，就不会换行了

转义字符

即用反斜杠\+字母实现某些功能

比如

• 输出特殊字符：print('\'')，需要在引号前加一个反斜杠表示转义
• 实现功能：\n换行 \b退格 \r将光标回到开头，光标之前的数据会被覆盖

也可以在字符串前加上r，让字符串种的转义字符不起作用

比如print(r'hello\nworld')会输出\n

编码与进制转换

ord()函数用来返回单个字符的ASCII码值，或者是unicode数值

chr()函数用来返回整数(0~255)的ASCII符号

bin()函数将其他数转换为二进制数

oct()函数将其他数转换为八进制数

hex()函数将其他数转换为十六进制数

int(number,type)函数将其他进制转换为十进制，第一个参数填数字，第二格填进制类型

变量

定义上来说是数据的一个标签

candle=1220

变量由三个部分组成，分别是：

• 标识：表示对象所存储的内存地址，使用函数id(obj)获取
• 类型：表示对象的数据类型，使用函数type(obj)获取
• 值：表示对象所存储的具体数据，使用print(obj)可以直接输出

数据类型

int整数类型

• 英文全称为integer，简写为int，可以表示正负数

float浮点数类型

• 由整数部分和小数部分组成，为了保证浮点运算的精度，可以导入decimal模块

bool布尔类型

• 表示真or假的值，True表示真，数值为1，False表示假，数值为0

str字符串类型

• 称为不可变的字符序列,可以使用单引号,双引号,三引号定义

类型转换

为了将不同数据类型的数据拼接在一起，所以需要进行类型转换

int之间的除法是会产生float的，54/10=5.4

str()函数可以将其他类型转换为str类型，也可以直接用引号转换

int()函数可以将其他类型转为int类型，注意float转换都int时，会抹零

函数Input()

作用：接收来自用户的输入

返回值类型：输入值类型为str，如果要进行运算请先转换

值的存储：设置一个变量

1
2

candle=input('write something')
print(candle)

input()函数内可以写字符串，以提示信息

运算符

算术运算符

a=20,b=10

比较运算符

以下假设变量a为10，变量b为20：

实际上，python了提高内存利用效率对于一些简单的对象，如一些数值较小的int对象，python采取重用对象内存的办法，如指向a=2，b=2时，由于2作为简单的int类型且数值小，python不会两次为其分配内存，而是只分配一次，然后将a与b同时指向已分配的对象,从而导致a is b =True

逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13，二进制格式如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

结构

对象的布尔值

Python中一切都是对象，所有对象都有一个布尔值

可以使用bool()函数获取布尔值，以下对象的布尔值为False

• False
• 0
• 空字符串 空列表 空字典 空集合

if-else结构

1
2
3
4

if 判断条件：
    执行语句……
else：
    执行语句……

当有多个值要判断时，可以使用if的嵌套结构

1
2
3
4
5
6
7
8

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

elif是else if的缩写

条件表达式

语法如下, 将if和else写到一行, 先执行condition_expr， 若执行结果为True则执行 expr1, 执行结果为False则执行expr2

m = a if a < b else b

range函数

用于生成一个整数序列，有三种创建方式

1
2
3
4
5
6

range(10)  #默认从0开始  [0,1,2,3,4,5,6,7,8,9]

range(1,10)  #指定了其起始值，从1开始，到10结束(不包括10)

range(1,10,2)  
#指定了起始值，最终值，步长，从1开始，间隔为2，输出[1,3,5,7,9]

如果想要倒序输出，则将步长设置为-1，比如range(10,-1,-1)，则实现了从10到0的倒序输出了

用 in 判断指定的整数是否在序列中，会返回True or False

print (9 in r) #返回值为 True

for in 循环

for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

结构如下：

1
2

for i in sequence:
   statements(s)

sequence可以是一个range函数，也可以是一个字符串或列表

如果循环体不需要使用自定义变量，那么可以写成下划线 “__”

break和continue

执行break会跳出整个循环

执行continue只会跳出这一次循环

列表

相当于是其他语言中的数组，线性结构存储数据

但是和其他语言不同的是，python中的列表中元素，可以不是同一个数据类型

创建

• 中括号

  lst=['candle','rainrain',1220,0420]

• 使用内置函数list()

  lst2=list(['candle','rainrain',1220,0420])，list()函数也可以把其他的数据结构转换为列表，比如lst=list(range(6))

本质上，列表list存储的只是列表对象的地址，lst存储的是列表的地址

1
2
3

lst=['candle','rainrain',1220,420]
print(id(lst))  # 列表的地址
print(id(lst[0]))  # 列表元素的地址

特点

• 列表元素按顺序有序排序
• 索引映射唯一一个数据
• 列表可以存储重复数据
• 任意数据类型混合存储
• 根据需要动态分配和回收内存

访问

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

通过索引列表可以进行截取、组合等操作。

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符，参数为list[start:stop:step]

比如想输出第1到第5个元素，可以写成nums[0:5]，默认步长为1

输出列表中奇数位元素，可以写成nums[1::2]

甚至可以用nums[::-1]实现数组的逆序访问

寻找

可以简单地使用in来判断元素是否在列表中，会输出True or False

print(candle in lst) #True

通过list.index(value)方法查询

• 如果列表中存在N个相同元素，只返回第一个元素的索引
• 如果查询的元素不存在，则会抛出ValueError
• 可以指定参数，在一定的范围内查找

增加

list.append(value)方法

• 在列表的末尾添加一个元素

list.extend(seq)方法

• 在列表的末尾至少添加一个元素，可以直接给列表添加另一个列表lst1.extend(lst2)

list.insert(place,value)方法

• 在列表的任意位置添加一个元素，前一个参数指定添加的位置，后一个参数指定要添加的元素

可以用切片的方法直接替换掉元素

• 比如lst1[1:]=lst2，执行该语句后，lst1列表中第一个元素以后的数据都被lst2所替换了

删除

list.remove(value)的方法

• 从列表中移除一个元素，如果有重复元素，只移除第一个

list.pop(place)的方法

• 从列表中移除指定位置的元素，如果没指定位置，会删除最后一个元素】

切片

• 可以直接用lst[start:stop]=[]的方法，将列表在(start,stop]区间元素进行删除

list.clear()的方法

• 直接删除列表中所有元素

排序

list.sort()方法

• 可以实现列表元素内部的排序，默认是升序排列
• 可以添加参数，list.sort(reverse=True)，实现降序排列

sorted(seq)函数

• 会产生一个新的列表对象，newlist=sorted(list)，也可以指定参数实现降序排序，newlist=sorted(list,reverse=True)

生成

语法格式为 newlist=[元素表达式 for 自定义变量 in 可迭代对象]

比如：

会在列表中生成[1,4,9..]的序列

字典

定义

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

1

d = {key1 : value1, key2 : value2, key3 : value3 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

字典在计算机中是无序存放的，通过寻找key从而来找到value

创建

使用花括号

• 例如：good={'candle':1220,'rainrain':420}

使用内置函数dict()

• dict(name='candle',age=1220)

访问

直接输入键来访问值

• print(good['candle']) #输出 1220，如果查找的键不存在会报错

通过dict.get(key)方法

• print (good.get('candle'))，如果查找的键不存在，会返回None，也可以人为指定不存在时返回的默认值

修改

查询

• 可以使用in查询键是否在字典中存在

删除

• 使用del dict[key]来删除指定的键值对

添加

• 直接进行添加即可 good['new']='newnew'

遍历

获取key

• 使用dict.keys()方法可以获取字典中的所有key
• 可以使用list()内置函数将输出的key转化为列表，lst=list(good.keys())

获取value

• 使用dict.values()方法可以获取字典中的所有value

获取key-value对

• 使用dict.items()方法可以获取字典中所有的key-value对

字典和range函数，列表一样，都是一个可迭代的对象，可以用for...in...结构遍历

1
2
3
4

for item in good
    print(item)  #遍历输出所有的键
    print(good[item]) #遍历输出所有的值
    print(good.get(item))#另一种输出值的方式

还可以同时遍历字典的key和value

1
2

for k, v in good.items():
    print(k,v)

生成

通过zip()函数生成

语法格式为 newdict=[key表达式:value表达式 for key自定义变量：value自定义变量 in zip(可迭代对象)]

元组

定义

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

元组中存储的是对象的引用

• 如果元组中对象本身不可变，则不能再引用其他对象
• 如果元组中的对象是可变对象，这可变对象的引用不允许改变，但数据是可变的，比如：假设元组里面有一个列表，则列表里面的数据是可以改变的

创建

使用小括号

• a=('candle','rain')

使用内置函数tuple()

• a=tuple(('candle','rain'))

只包含一个元组的元素需要使用逗号和小括号

• a=('candle',)不加逗号会被识别成字符串

遍历

元组是可迭代对象，所以可以用for ... in...遍历

集合

集合（set）是一个无序的不重复元素序列。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

创建

直接使用花括号{}

• s={1,2,3,4}

使用内置函数set()

• s=set(range(6)),set()函数也可以把其他的数据结构转换为集合，比如s=set(lst)

添加

set.add(key)方法

• 一次可以添加一个元素，s.add('candle')

set.update(seq)方法

• 一次至少添加一个元素，可以添加一个列表之类的，s.update(lst)

和列表是类似的

删除

set.remove(key)方法

• 一次删除一个指定元素，如果不存在就异常

set.discard(key)方法

• 一次删除一个指定元素，如果不存在也不会异常

set.pop()方法

• 一次删除一个任意元素

关系

正如数学中的集合一样，python中的集合有各种关系

相等

• 可以使用运算符== 判断

子集

• 调用set.issubset(set)方法判断，如果a.issubset(b)是True，那么a是b的子集

交集

• 调用方法set.isdisjoint(set)判断,如果有交集，会输出True，
• 调用方法intersection()可以直接返回集合的交集，或者用&运算符，s1.intersection(s2)等价于s1 & s2

并集

• 调用方法set.union(set)可以合并两个集合，相同元素会被舍弃，或者用|运算符

差集

• 调用方法set.difference(set)可以出两个集合的差集，或者用-运算符

数据结构总结

字符串

字符串本身就是一个字符数组，这意味着你可以通过范围下标的方式来访问字符串的单个字符，比如

1
2

s='candle'
print(s[1]) #结果会输出'a'

查询

str.index(str)方法

• 查询子串substr第一次出现的位置，如果不存在，就抛出异常

str.rindex(str)方法

• 查询子串substr最后一次出现的位置，如果不存在，抛出异常

str.find(str)方法

• 查询子串substr第一次出现的位置，如果不存在，则返回-1

分割

str.split()方法

• 从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表 print(s.split())

• 可以指定参数，比如sep参数，可以选择劈分的依据 s.split(seq='|')会以字符|分界点进行分割

• split()方法的返回结果是一个列表

• 如果想要字符串分割成单独的字符，用list()方法就行了

替换与合并

str.replace(old,new)方法

• replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)

str.join(seq) 方法

• 将列表或元组中的字符串合并成一个字符串，效果是会在seq序列中间以str为间隔

1
2
3
4

s1='-'
s2='candle'
print(s1.join(s2)) 
#会输出：c-a-n-d-l-e

切片

和列表一样，字符串也可以通过切片的方式截取，遵循左闭右开的原则

比如print(s[1:5])，会输出字符串第2个到第5个元素

格式化

• 使用花括号{}

  字符串中可以用{ }作为占位符，里面输入整数作为次序，调用format方法，实现格式化字符串

  1 2 3 4

  name='candle' key='rain' print('my name is {0},love {1}'.format(name,key)) #会输出 my name is candle,love rain

• 使用f-string

  在字符串之前加字符 f ，说明之后的字符串可以直接使用变量

  1 2 3

  name='candle' key='rain' print(f'my name is {name},love{key}')

函数

定义

1
2
3

def name(parameter) :
    function
    (return) 

返回值

和其他语言不同的是，python允许多个返回值，结果为元组

1
2
3
4
5
6

def test():
    a=2
    b=3
    return a,b

print(test()) #会输出(2,3)元组，可以用list()变成列表

参数

默认参数

函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递参数

def fun (a,b=10)的意思是，如果只传一个参数，默认b=10，如果传了两个参数，这b的值被替换

1
2
3
4
5

def fun (a,b=10):
    return a,b

print(fun(20))  # 会返回(20,10)，b的值是默认值
print(fun(20,30)) # 会返回(20,30)，b的值被修改

位置传参

如果想要将列表中的每个元素当做位置参数传入的话，如果在传入时加*

1
2
3
4
5
6

def fun(a,b,c):
    print(a,b,c)
    
lst=['candle',1220,420]
fun(*lst)

如果不加*会报错，因为相当于只传入列表的首地址，也就是第一个元素

关键字传参

如果想要将字典中的每个键值对当做位置参数传入的话，如果在传入时加**

1
2
3
4
5
6
7
8

def fun(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)

dic = {'c':1220,'b':420,'a':520}
fun(**dic)

个数可变的参数

定义函数时，如果无法事先确认传递的位置实参个数时，使用可变的位置参数，用*定义

1
2
3
4
5
6

def fun(*args):
    print(args)
    
fun(10)
fun(10,20)
fun(10,20,30)

输出的结果都是 元组

个数可变的关键字参数

定义函数时，如果无法事先确认传递的关键字个数时，使用可变的关键字参数，用**定义

1
2
3
4
5

def fun(**args):
    print(args)
    
fun(a=10)
fun(a=10,b=20)

输出的结果为 字典