python 学习过程总结

1.

+的三种用法

①数的相加

②字符串相加

print ("Hello,"+str+"!") 加号可以连接字符串和列表，但是要返回一个新字符串

③列表相加

list1=[1,2]

list2=[3,5]

list3=list2+list1

print(list3)

输出：[3, 5, 1, 2]

2.

①split()函数：

拆分字符串。通过指定分隔符对字符串进行切片，并返回分割后的字符串列表（list）

语法：str.split(str="",num=string.count(str))[n]

参数说明：

str：   表示为分隔符，默认为空格，但是不能为空('')。若字符串中没有分隔符，则把整个字符串作为列表的一个元素

num：表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量

[n]：   表示选取第n个分片

注意：当使用空格作为分隔符时，对于中间为空的项会自动忽略

②、map函数：

map()函数接收两个参数，一个是函数，一个是Iterable(字符串)，map将传入的函数依次作用到序列的每一个元素，并把结果作为新的Iterable返回。其语法格式为：

                                                        map(function，iterable...)

                                                        function---函数名

                                                        iterable---一个或多个序列

map作为高阶函数，事实上它把运算规则抽象了，我们可以用这种方式计算任意复杂的函数，再比如，把一个list的所有数据转为string类型：int转string

结果显示

再举一个小例子，对list中的各个元素开方，一步到位：

！注意：在使用math自带函数时，只需要函数名即可

③理解一下常见输入

连续输入两个相隔空格的整数

a,b=map(int,input().split())

连续输入三个相隔空格的整数

a,b,c = map(int,input().split(' '))

连续输入两个以固定符号分隔

a,b=map(int,input().split(","))

连续输入两个以固定符号，分隔（提示：A和B前面可能有空格）

先去空格然后 a,b=map(int,input().split(","))

特别注意一下情况

3.

①#格式化字符串的函数 str.format()，它增强了字符串格式化的功能，和格式化输出%d

基本语法是通过 {} 和 : 来代替以前的 % 

print('{0}{1}={2}'.format(a, b, c))    

print("{1} {0} {1}".format("hello", "world")) 前面括号中是后面括号中的序号

②# 通过字典设置参数

site = {"name": "菜鸟教程", "url": "www.runoob.com"}

print("网站名：{name}, 地址 {url}".format(**site))

输出：网站名：菜鸟教程, 地址 www.runoob.com

注意：**site在format函数调用里的意思是将字典包传递给format函数。

③# 通过列表索引设置参数

my_list = ['菜鸟教程', 'www.runoob.com'] print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的

输出：网站名：菜鸟教程, 地址 www.runoob.com

④#不带字段默认情况

print('{} {}'.format('hello','world'))  # 不带字段

print("{:.2f}".format(c))等同于print("%.2f" %(c))

4.

打印python中的关键字

import keyword

print(keyword.kwlist)

5.

复数

x = complex(a, b) 返回一个复数

print(int(x.real),int(x.imag)) 获取复数的实部和虚部

6.

①字符串大小写转换

print(str.upper())          # 把所有字符中的小写字母转换成大写字母
print(str.lower())          # 把所有字符中的大写字母转换成小写字母
print(str.capitalize())     # 把一整行字符串第一个字母转化为大写字母，其余小写
print(str.title())          # 把每个单词的第一个字母转化为大写，其余小写

②字符串数字判断

print (str.isdigit())#判断字符串中是否只包含数字

print (str.isnumeric())#方法检测字符串是否只由数字组成

print (str.isdecimal())#方法检测字符串是否只由数字组成

以上三种方式编码方式不同

③字符串字母判断

print(str.isalpha())   #用isalpha判断是否仅有字母

print(str.isalnum())   #isalnum判断是否数字和字母的组合，

如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False，如果有空格也会返回False

7.

多组输入的方法

while True:

    try:

    except:break

8.

输入的符号中带%方式

print("%.2f%% %.2f%%"%(a,b))

9.

①向上取整

math.ceil(2.3)

②向下取整

math.floor(2.3)

③四舍五入

round(2.3)没有math

8.

python运算符

+	加 - 两个对象相加
-	减 - 得到负数或是一个数减去另一个数
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串
/	除 - x除以y，直接得到小数点的数
%	取模 - 返回除法的余数
**	幂 - 返回x的y次幂，注意运算式加括号
//	取整除 - 返回商的整数部分（向下取整）

9.

①sort()方法语法：

List .sort ( cm p=None, key=None, reverse=False)

参数：

 cm p  -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序

reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）

返回值

该方法没有返回值，但是会对列表的对象进行排序。

②sorted（）语法：

sorted(iterable, cmp=None, key=None, reverse=False)

参数：

iterable -- 可迭代对象

cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序

reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回值

返回重新排序的列表。

③sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

10.

①Join( )函数

Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

join()方法语法：

str.join(sequence)

参数：

sequence -- 要连接的元素序列（列表或者字符串）。

返回值

返回通过指定字符连接序列中元素后生成的新字符串。

示例

print("<".join(chr(x) for x in li))

11.

字符串倒置

reserved()

其功能是对于给定的序列（包括列表、元组、字符串以及 range(n) 区间）

该函数可以返回一个逆序序列的迭代器（用于遍历该逆序序列）

语法格式如下：

reversed(seq)

其中，seq 可以是列表，元素，字符串以及 range() 生成的区间列表

示例

a = reversed(list(str))

10.空格的删除，返回值是新串

删除左边的空白	print(s.lstrip())
删除右边的空白	print(s.rstrip())
删除两边的空白	print(s.strip())

11.

①字符串查找函数

Find	查找，返回从左第一个指定字符的索引，找不到返回-1
rfind	查找，返回从右第一个指定字符的索引，找不到返回-1
index	查找，返回从左第一个指定字符的索引，找不到报错
R index	查找，返回从右第一个指定字符的索引，找不到报错
count	计数功能，返回自定字符在字符串当中的个数

②统计字符串中字符及串的次数

a="good"	结果
统计a.count("o")统计"o"出现的次数	2
统计a.count("go")##统计go出现的次数	1
统计a.count("ood")	1
获得字长len(a)	4
统计a.count("o",0,4)##指定统计范围统计o出现的次数	2

③列表查找函数

	列表查找函数
index	查找，返回从左第一个指定元素的索引，找不到报错
count	计数功能，返回自定元素在列表当中的个数

12.

①replace() 方法

用于把字符串中指定的旧子字符串替换成指定的新子字符串

②replace() 方法语法：

S.replace(old,new[,count=S.count(old)])

如果指定 count 可选参数则替换指定的次数，默认全部替换。

参数

old -- 指定的旧子字符串

new -- 指定的新子字符串

count -- 可选参数，替换的次数，默认为指定的旧子字符串在字符串中出现的总次数。

返回值

返回把字符串中指定的旧子字符串替换成指定的新子字符串后生成的新字符串，

如果指定 count 可选参数则替换指定的次数，默认为指定的旧子字符串在字符串中出现的总次数。

14.

如何把各种进制转换成前面带0的二进制的字符串？

1. 第一步：首先把十进制变成对应进制
2. 第二步：省去前缀str2=str2[2:]
3. 第三步：计算串长n=len(str2)
4. 第四步：变换成固定位格式字符串y1='0'*(32-n)+str2（或者用printf("{:032s}".format(str2)）

如何进行十进制与其他进制的相互转换？

1. 其他进制转十进制：x=Int(变量,进制数)

输入	结果
int(3.1415926)	3
int(-11.123)	-11
int(2.5,10)	报错，2.5已经十进制了
int("9",2)	报错，因为2进制无9
int("9")	9，默认十进制
Int('01010100101',2)	677
int("3.14",8)	str须为整数
int("1.2")	str须为整数
int("1001",2)	"1001"才是2进制格式,并转化为十进制9
int("0xa",16)	16进制才会允许入参为a,b,c转换成10
int("b",8)	超过范围报错

注意：如果变量是整数，那么进制数不能有参数，若 变量 为 str,则 base 可略可有

1. 十进制转换其他进制：都变成字符串

a=5	输入
print(bin(a),oct(a),hex(a))	1
print(type(bin(a)),type(oct(a)),type(hex(a)))	2
0b101 0o5 0x5	输出1
<class 'str'> <class 'str'> <class 'str'>	输出2

   ③ .其他进制之间的相互转换：oct、bin、hex参数为整型

十六进制转换成十进制字符串 => str1=str(int(result,16))

十六进制字符串转换成八进制 => str2=oct(int(result,16))

十六进制字符串转换成二进制=>str3=bin(int(result,16))

二进制字符串转换成十六进制=>str4=hex(int(str,8))

15.

1. 从一个字符串中跳出挑出字符，利用for循环遍历+范围筛选
2. 把列表转化成字符串=>result = ''.join(list1)
3. 可变不可变类型，可变（列表、元组）不可变（字符串、元组、数字）
4. 对大写字母的筛选范围、两种方式if语句和python函数alpha()
5.  ASCLL的转换，ord('a')就转换成ASCALL，chr(i)把ASCLL转换成字符

18.

关于enumerate（）

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，

同时列出数据和数据下标（下表，值），一般用在 for 循环当中。把列表转换成为li=list(enumerate(a))

for 循环遍历使用 enumerate	题目
seq = ['one', 'two', 'three']	输入
for i, element in enumerate(seq):
print i, element
0 one 1 two 2 three	输出结果

19.

列表元组集合字典常用的操作

**python中列表 元组 字典 集合 - 无名小妖 - 博客园

20.

not、not in、is not三者的区别

1. in在Python中是操作符，具体来说是成员操作符。就是对于序列（字符串，元组，列表）或集合（set）或映射（字典）这些数据类型做成员判断
2. not in：成员运算符，功能是运算某个变量是否包含某个元素，可以简单的理解为不包含的意思，返回的结果是TR
3. not：逻辑运算符，功能是进行非运算，可以简单的理解不对或者错误的意思，输出的结果是TRUE或者FALSE
4. is not：身份运算符，判断两个变量是不是引用自不同对象，可以简单的理解为非引用同一对象，返回的结果是TRUE或者FALSE

21.

set() 函数

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

x = set('runoob')

set(['b', 'r', 'u', 'o', 'n'])

 

22.

输入一个矩阵

for i in range(n):
list.append(input().split())	其实是列表中嵌套列表

求矩阵主对角线，副对角线、上三角矩阵、下三角矩阵之和（矩阵的长宽已知）

for i in range(n):

for j in range(n):

if i==j or i+j==n-1:

summ=summ+int(list[i][j])

if i < j:

sum1 = sum1 + int(a[i][j])

if j < i:

sum2 = sum2 + int(a[i][j])

矩阵的逆置

for row in range(n):

for clo in range(m):

li1.append(li[clo][row])

打印图形矩阵

strx = '*'

n = int(input())

for i in range(n):

    for j in range(n):

        print(strx, end='')

    print()

打印三角形具有如下图像

打印图案1矩阵

strx = '*'

n = int(input())

for i in range(n):

    for j in range(n):

        if j <= i:

            print(strx, end='')

    print()

打印图案2矩阵

strx = '*'

n = int(input())

for i in range(n):

    for j in range(n):

        if j >= i:

            print(strx, end='')

    print()

打印图案3矩阵

strx = '*'

n = int(input())

for i in range(n):

    for j in range(n-i-1):

            print(' ', end='')

    for j in range(n):

        if j <= i:

            print(strx, end='')

    print()

打印图案4矩阵

strx = '*'

n = int(input())

for i in range(n):

    for j in range(n):

        if j < i:

            print(' ', end='')

    for j in range(n):

        if j >= i:

            print(strx, end='')

    print()

打印菱形

杨辉三角

n=int(input())

tri=[0]*n

for i in range(n):

    tri[i]=[0]*(i+1)

    tri[i][0]=1

    tri[i][i]=1

    for j in range(1,i):

        tri[i][j]=tri[i-1][j-1]+tri[i-1][j]

格式杨辉三角

25.

eval() 函数用来执行一个字符串表达式，并返回表达式的值，

可以运行字典建对应的表达式

li=eval(input())	#输入一个列表可以用eval转换成列表
dict=eval(input())	#输入一个列表可以用eval转换成字典

26.

add() 方法用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。

set.add(elmnt)#返回值=>None

27.

列表切片

data[:-1]：去掉最后一个

s = 'ASTRING'	结果
s[:-1]	# 'ASTRIN'
s[:len(s) - 1]	# 'ASTRIN'
s[0:len(s) - 1]	# 'ASTRIN'

data[-1:]：只取出最后一个值

s = 'ASTRING'	结果
s[-1:]	# 'G'

28.

Printf
参数：
end：	结尾以什么结尾
sep：	逗号代表什么分隔

29.

31.

列表是[]

元组是（1，2）

集合是 [不重复]

字典是{ }

29.列表推导式

sum([int(j)**mforjinstr(i)])

30.

l=input()

p=eval(l)

For I in p:

print(p[i])

遍历字典中的所有值，i会表示字典的key

31.

#。keys()方法用于返回字典中的所有键；

#values()方法用于返回字典中所有键对应的值；

#items()用于返回字典中所有的键值对。

isinstance() 函数来判断一个对象是否是一个已知的类型

isinstance (a,int)

 True

31.字符串总结

明确：对字符串的操作方法都不会改变原来字符串的值

 

1，去掉空格和特殊符号

name.strip()  去掉空格和换行符

name.strip('xx')  去掉某个字符串

name.lstrip()  去掉左边的空格和换行符

name.rstrip()  去掉右边的空格和换行符

 

2，字符串的搜索和替换

name.count('x')  查找某个字符在字符串里面出现的次数

name.capitalize()  首字母大写

name.center(n,'-')   把字符串放中间，两边用- 补齐

name.find('x')   找到这个字符返回下标，多个时返回第一个；不存在的字符返回-1

name.index('x') 找到这个字符返回下标，多个时返回第一个；不存在的字符报错

name.replace(oldstr, newstr)  字符串替换

name.format（） 字符串格式化

name.format(d)  字符串格式化，传进去的是一个字典

 

3，字符串的测试和替换函数

S.startswith(prefix[,start[,end]]) 

#是否以prefix开头 

S.endswith(suffix[,start[,end]]) 

#以suffix结尾 

S.isalnum() 

#是否全是字母和数字，并至少有一个字符 

S.isalpha() #是否全是字母，并至少有一个字符 

S.isdigit() #是否全是数字，并至少有一个字符 

S.isspace() #是否全是空白字符，并至少有一个字符 

S.islower() #S中的字母是否全是小写 

S.isupper() #S中的字母是否便是大写 

S.istitle() #S是否是首字母大写的

4，字符串的分割

name.split()  默认是按照空格分割

name.split(',')   按照逗号分割

5，连接字符串

‘，’.join(slit)      用逗号连接slit 变成一个字符串，slit 可以是字符，列表，字典（可迭代的对象）

                        int 类型不能被连接

 6，截取字符串（切片）

str = '0123456789′

print str[0:3] #截取第一位到第三位的字符

print str[:] #截取字符串的全部字符

print str[6:] #截取第七个字符到结尾

print str[:-3] #截取从头开始到倒数第三个字符之前

print str[2] #截取第三个字符

print str[-1] #截取倒数第一个字符

print str[::-1] #创造一个与原字符串顺序相反的字符串

print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符

print str[-3:] #截取倒数第三位到结尾

print str[:-5:-3] #逆序截取

7.string 模块

import string 

string.ascii_uppercase  所有大写字母

string.ascii_lowercase 所有小写字母

string.ascii_letters  所有字母

string.digits  所有数字

 

8.长字符串跨行

可以用下面几种方式

1、字符串用三引号'''、或三个双引号"""括起来

a = '''Hello,
world'''print(a)

运行结果：

Hello,

World

2、行尾加上反斜杠 \，运行结果和上面区别是字符串不换行

b = "Hello,\
world"print(b)

运行结果：

Hello,world

3.如果要指定以反斜杠结尾，需要再加2个反斜杠 \

b = "Hello,\\\
world"print(b)

运行结果：

Hello,\world

 

9.原始字符串，前缀加上r

print('c:\now')
print(r'c:\now')

运行结果如下，原始字符串会原样输出：

c:

ow

c:\now

原始字符串不能以单个反斜杠 \结尾，如果要指定以反斜杠结尾，可以将反斜杠单独作为作为一个字符串

print(r'c:\now''\\')

运行结果：

c:\now\

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

List.pop(obj)

list.pop([index=-1])

• obj -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

print(list(range(2,12,2))[:-2].pop())

print(list(range(2,12,2))[:-2])

print(list(range(2,12,2)))

6

[2, 4, 6]

[2, 4, 6, 8, 10]

 

 

 

列表元组遍历的三种方式

students=[(3180102988,"褚好"),
          (3170102465,"王凯亮"),
          (3160104456,"李永"),
          (3171104169,"陈鑫"),
          (318400429,"徐杭诚")]

#第一种输出方式
for row in students: #按行存取
    print(row[0],row[1])
print()
#第二种输出方式
for id,name in students: #按行拆包存取
    print(id,name)
print()
#第三种输出方式
for index in range(len(students)):  #按索引存取
    print(students[index][0],students[index][1]）

 

列表中*是不改变元组位置的简单引用

#这里是三行不用的变量

data=[]

foriinrange(3):

data.append([0]*3)

print(data)

data[2][2]=7

print(data)

#这里是一个变量展现三次

row=[0]*3

data=[row,row,row]

print(data)

data[2][2]=7

print(data)

#这里是一个变量展现三次

data=[[0]*3]*3

print(data)

data[2][2]=7

print(data)

[[0, 0, 0], [0, 0, 0], [0, 0, 7]]

[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

[[0, 0, 7], [0, 0, 7], [0, 0, 7]]

[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

[[0, 0, 7], [0, 0, 7], [0, 0, 7]]

 

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

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

集合的元素必须是不可变类型。

字典键值互转

dic={"John" : 15264771766,"Kate" : 13063767486,"Rose" : 15146046882,"Chise" : 13606379542,"Jason" : 13611987725}
reverseDic={v:k for k,v in dic.items()}
print(reverseDic[13063767486])

 

update() 方法可使用一个字典所包含的键值对来更新己有的字典。

该方法没有任何返回值。

 

在执行 update() 方法时，如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

例如：

1. a ={'one':1,'two':2,'three':3}
2. a.update({'one':4.5,'four':9.3})

1. print(a)

运行结果为：

{'one': 4.5, 'two': 2, 'three': 3, 'four': 9.3}

从上面的执行过程可以看出，由于被更新的 dict 中已包含 key 为“one”的键值对，因此更新时该键值对的 value 将被改写；但如果被更新的 dict 中不包含 key 为“four”的键值对，那么更新时就会为原字典增加一个键值对。

Python提示object is not subscriptable的错误

 

subscriptable的意思是 可有下标的 意思

错误的原因就是把不具有下标操作的对象用成了对象[i]，比如int对象变量[i]就会报错。仔细检查错误行。

字典的引用：get方法返回设置的默认值，不设置默认为None，直接引用找不到报错

dic={"John":15264771766,"Kate":13063767486,"Rose":15146046882,"Chise":13606379542,"Jason":13611987725}

print(dic['ABCD'])

dic={"John" : 15264771766,"Kate" : 13063767486,"Rose" : 15146046882,"Chise" : 13606379542,"Jason" : 13611987725}
print(dic.get('ABCD',None))

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

语法

以下是 isinstance() 方法的语法:

isinstance(object, classinfo)

参数

• object -- 实例对象。
• classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

返回值

如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。