python学习笔记

python学习笔记

1.字符串

字符串拼接方法

1.str.join()

	wangzhi= ['www','baidu','com']
	new_wangzhi='.'.join(wangzhi)
	print(new_wangzhi)12

输出结果：www.baidu.com

字符串大小转换方法

1.str.upper() 将字符串全部大写

str = 'i love you'print(str.upper())12

输出结果： I LOVE YOU

2.str.lower（) 将字符串全部小写

str = 'I LOVE YOU'print(str.lower())12

输出结果：i love you

3.str.title() 将字符串每个单词的开头大写

str = 'i lovr you'print(str.title())12

输出结果：I Lovr You
4.str.capitalize()字符串当作整体只将第一个单词大写

str = 'i lovr you'print(str.capitalize())12

输出结果：I lovr you
5.swapcase() 将字符串的大小写互相转换

str = 'i LovR You'print(str.swapcase())12

输出结果：I lOVr yOU

字符串检索

str.count() 统计字符串里指定子字符出现的次数

str.count（“被检索的字符串”，检索的起始位置，检索的结束位置）
起始位置和结束位置可以省略，默认为第一个字符到最后一个字符。第一个字符索引值为0。Python区分大小写

str = 'I love you'print(str.count('o'))123456

输出结果：2

2.str.find（）查找某字符串里是否包含被查询的子字符串

str.find（“被检索的字符串”，检索的起始位置，检索的结束位置）查找时从左往右开始查找，如果找到被查询字符串，此方法返回该字符串的索引，否则返回-1，代表没有找到该字符串

str = 'I love you'print(str.find('o'))12

输出结果：3

str = 'I love you'print(str.find('f'))12

输出结果：-1

3.str.index（）查找某字符串里是否包含被查询的子字符串

str.index（“被检索的字符串”，检索的起始位置，检索的结束位置）查找时从左往右开始查找，如果找到被查询字符串，此方法返回该字符串的索引，找不到字符串时，抛出异常

str = 'I love you'print(str.index('o'))1

输出结果：3

str = 'I love you'print(str.index('f'))1

输出结果：报错异常

注：find()和index()相似但是find查找不到时返回-1，index查找不到时异常

4.str.starswith() 查询字符串是否以指定子字符串开头

str.starswith(“被检索的字符串”，检索的起始位置，检索的结束位置)如果找到了返回True,否则返回False

str = 'I love you'print(str.startswith('o',3))1

输出结果：True

str = 'I love you'print(str.startswith('o'))12

输出结果：False

5.str.endswith() 查询字符串是否以指定子字符串结尾

str.endswith(“被检索的字符串”，检索的起始位置，检索的结束位置) 如果找到了返回True,否则返回False

str = 'I love you'print(str.endswith('u'))1

输出结果：True

字符串分割

str.split(‘分隔符’，分割次数)

分隔符默认空格，\n \r \t

str = '我爱你 python 你\n呢\t?'print(str.split())1

输出结果：[‘我爱你’, ‘python’, ‘你’,‘呢’, ‘?’]

str = '我爱你哈python哈你哈呢?'print(str.split('哈'))1

输出结果：[‘我爱你’, ‘python’, ‘你’,‘呢?’]

str.splitlines() 以\n \r \r\n来分割行分割

str = '我爱你 python\n你\r呢?'print(str.splitlines())12

输出结果：[‘我爱你 python’, ‘你’,‘呢?’]

str.partition()

str.partition(‘切割符’) 从str出现的第一个位置起把字符串分为一个3元素的元组，以分隔符前后分为3部分

str = 'I love python'print(str.partition('o'))12

输出结果：(‘I l’, ‘o’, ‘ve python’)

字符串修建

str.strip() 默认移除字符串左右空格

str.lstrip() 移除左侧空格

str.rstrip() 移除右侧空格

2.列表

列表list[ ]：可重复，类型可不同，可新增，可删除

列表支持索引和切片，增删改查，排序复制

list.append(x)	把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]
list.extend(L)	通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x)	删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i])	从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在Python 库参考手册中遇到这样的标记。）
list.clear()	移除列表中的所有项，等于del a[:]。
list.index(x)	返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x)	返回 x在列表中出现的次数。
list.sort()	对列表中的元素进行排序
list.reverse()	倒排列表中的元素。
list.copy()	返回列表的浅复制，等于a[:]。

例：

a = [66.25, 333, 333, 1, 1234.5]

print(a.count(333), a.count(66.25), a.count(‘x’))

2 1 0

a.insert(2, -1)

a.append(333)

a

[66.25, 333, -1, 333, 1, 1234.5, 333]

a.index(333)

a.remove(333)

a

[66.25, -1, 333, 1, 1234.5, 333]

a.reverse()

a

[333, 1234.5, 1, 333, -1, 66.25]

a.sort()

a

[-1, 1, 66.25, 333, 333, 1234.5]

3.元组

元组tuple()：可重复，类型可不同，元素不可修改，一旦创建不能改变
元组支持索引和切片
创建元组时只有一个元素如tuple_1 = (1,) tuple_2 =
(‘hi’,) 时注意在元素后加逗号

4.集合

集合：{value1,value2}

创建空集合时要使用set()函数，{}创建的为空字典

集合是一个无序的数据值集合

集合自身虽然可以修改，但是对于集合中不可变类型的元素是不能修改的，只能添加不可变类型

集合中值是不能重复的，多个值只保留一个

集合的运算

交集运算

intersection() 移除两个集合没有共同不存在的元素，返回一个共同存在的元素的新集合

a = {1,3,5,7,9}b = {2,4,6,8,9}c = a.intersection(b)print(c)12345678

输出结果：{9}

2.intersection_update() 移除两个集合中没有共同存在的元素，没有返回值

a = {1,3,5,7,9}

b = {2,4,6,8,9}

a.intersection_update(b)

print(a)

输出结果：{9}

b作为参数传递，b不发生改变，而a调用intersection_update()函数更新，原来a的集合被改变

并集

union() 方法返回两个集合的并集，即一个包含了所有集合的元素，重复的元素只会出现一次

a = {1,3,5,7,9}b = {2,4,6,8,9}c = a.union(b)print(c)12345678

输出结果：{1, 2, 3, 4, 5, 6, 7, 8, 9}

差集
difference() 移除两个集合都存在的元素，方法返回一个移除都存在的元素后一个新集合

a = {1,3,5,7,9}b = {2,4,6,8,9}c = a.difference(b)print（c）12345678

输出结果：{1, 3, 5, 7}

4.difference_update()
移除两个集合都存在的元素，没有返回值，调用的函数被更新

a = {1,3,5,7,9}b = {2,4,6,8,9}a.difference_update(b)print(a)12345678

输出结果：{1, 3, 5, 7}

a调用的函数所以a被更新，b作为参数，没有发生变化

5.字典

dict= {key1:value1,key2:value2} 键为不可变类型
字典是一个无序的数据值集合，不支持索引和切片
字典的键必须唯一，但值则不一定唯一
字典在命名键名时不取相同，取相同键名时会默认取最后一个

字典的统计、合并、删除

len() 统计字典内键值对的数量

a = {'heigh':1.78,'weight':70,'age':20}print(len(a))12

输出结果：3

update() 合并字典

a = {'heigh':1.78,'weight':70,'age':20}b = {'age':22,'money':5000}a.update(b)print(a)12345678

输出结果：{‘heigh’: 1.78, ‘weight’: 70, ‘age’: 22,
‘money’: 5000}

如果被合并的字典中包含已经存在的键值对，会覆盖原有键值对

clear() 清空字典

a = {'heigh':1.78,'weight':70,'age':20}a.clear()print(a)12345

输出结果：{}

del dir[ ] 删除字典元素

del dir 删除字典

a = {'heigh':1.78,'weight':70,'age':20}del a['age']print(a['age'])123456

输出结果：异常

a = {'heigh':1.78,'weight':70,'age':20}del aprint(a[0])123456

输出结果：异常

6.函数

def 函数名（参数列表）: 函数体
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

def printinfo(arg1, *vartuple):

    "打印任何传入的参数"

    print(arg1)

    print(vartuple)

    printinfo(70, 60, 50)12345678910

输出结果：70(60,50)

加了两个星号 ** 的参数会以字典的形式导入。

def printinfo(arg1, **vardict):

    "打印任何传入的参数"
    print(arg1)

    print(vardict)printinfo(1, a=2, b=3)1234567891011

输出结果：1{‘a’:2, ‘b’: 3}

lambda [arg1 [,arg2,…argn]]:expression

sum = lambda num1, num2 : num1 + num2print(sum(10,20))12

输出结果：30

7.类

	class
		类名(object):
   	pass12

8.内置函数

map() 函数语法：

map(function, iterable, …)

function – 函数
iterable – 一个或多个序列
map()返回为迭代器

2.input().split()

用于接受多个用户输入，以空格分开输入内容