python学习笔记 第一天

Python的内存管理方式

在python中修改变量值的操作，并不是修改了变量的数值，而是修改了变量指向的内存地址。
首先读取x的值，然后加6，并将结果存放于内存中，最后将x指向该内存空间。
python采用的是基于值的内存管理方式，如果为不同的变量赋值为相同值，则这个值在内存中只有一份，多个变量指向同一内存。
python具有自动管理内存的功能，对于没有任何变量指向的值，python将其自动删除
示例代码：

x=3
y=3
print("x的id为："+str(id(x)))
print("y的id为："+str(id(y)))
x+=3;
print("修改x后x的id为："+str(id(x)))

运行结果

字符串

字符串既可以用单引号也可以用双引号甚至三引号，并且三者可以相互嵌套

message="ada lovelace"
message='ada loverlace'
print(message)

使用方法修改字符串的大小写str.title()、str.upper()、str.lower()这些都是临时的方法，不对原字符串进行修改，只返回一个新字符串。

print(message.title())
print(message.upper())
print(message.lower())

合并（拼接）字符串，使用 ‘+’

first_name="zhou"
last_name="yi"
print((first_name.title()+last_name.title()))

使用制表符（\t)和换行符（\n)

print("\tJoy\tLike\tFood")
print("Joy\nLike\nFood")
print("Joy\n\tLike\n\tFood")

删除字符串中的空白str.strip()、str.lstrip()、str.rstrip()

favorite_languge="  python  "
print(favorite_languge.strip()) #去除两端的空格
print(favorite_languge.rstrip()) #去除右端的空格
print(favorite_languge.lstrip())#去除左端的空格

判断字符串是否以另外一个字符串开头或结尾str.startswith(str1),str.endswith(str1)

print(message.endswith("ada"))#输出结果：False
print(message.startswith("ada"))#输出结果:True

字符串填充 str.center(),str.ljust(),str.rjust()

print("ww".center(10,"e"))#输出结果：eeeewweeee
print('m'.ljust(10,'k'))#输出结果：mkkkkkkkkk
print('c'.rjust(10,'k'))#输出结果：kkkkkkkkkc

python支持字符串按从右-1编号，也可以切片——str[start:end]或者str[start🔚step]

myName='ZhouYi'
print("first_name="+str(myName[0:4]))#输出结果：Zhou
print("first_name="+str(myName[0:4:2]))#输出结果：Zo
print("last_name="+str(myName[-2:]))#输出结果：Yi

字符串中的其它方法

find()
类似于java中的indexOf。在字符串中查找子串。返回子串第一次出现在字符串中的索引，没找到返回-1。甚至支持限定索引的范围 find(substr,startIndex,endIndex)

str='help me! help me!'
print(str.find('me'))#输出结果：5
print(str.find('me', 6, len(str)))#从索引6开始找，到结尾。输出结果：14

split()
用于将字符串分割成 列表

str='1,2,3,4,5'
numList=str.split(',')#不提供参数则以所有空格(包括制表和换行)作为分隔符
print(numList)#输出结果为：['1', '2', '3', '4', '5']

join()
join方法是split的逆方法，用来连接列表中的元素，并返回字符串。
注意是参数是序列，且需要连接的序列元素都必须是字符串。

#numList=[1,2,3,4,5] 该列表中的元素是数字，temp.join(numlist)会报错
numList1=['1','2','3','4','5']
temp=','
temp.join(numList)

replace()
用来替换字符串,返回某字符串的所有匹配项被替换之后的字符串

str="I love you"
print(str.replace('love','hate'))#输出结果为：I hate you在这里插入代码片

字符串的maketrans()和translate()的使用(目的是为了替换 字符串中的某些字符)

当替换某个字符串中的某些字母时也许会使用replace()方法,但是这得需要多次使用,比较麻烦,其实python还提供了更加方便的函数,这就是makestrans()和translate(),这两个函数需要配合使用才可以实现上面的要求.
maketrans()
str.maketrans 返回一个可以用于 str.translate 函数中的翻译表。
它可以接收一个、两个和三个参数。
接收一个参数时，必须是一个字典，该字典是从 Unicode 序数（整数）或者字符到 Unicode 序数、字符串或者 None 的映射。
接收两个参数时，必须是两个长度相等的字符串，在结果字典中，x 中的字符会被映射到 y 中同位置上的字符。
接收三个参数时，最后一个参数是一个字符串，在结果字典中它被映射到 None。

>>> table1 = {ord('1'): ord('a'), ord('2'): ord('b')}
>>> table1
{49: 97, 50: 98}
>>> table2 = str.maketrans({'1': 'a', '2': 'b'})
>>> table2
{49: 'a', 50: 'b'}
>>> table3 = str.maketrans('12', 'ab')
>>> table3
{49: 97, 50: 98}
>>> table4 = str.maketrans('12', 'ab', '中文')
>>> table4
{49: 97, 50: 98, 20013: None, 25991: None}

translate()
str.translate(table) 函数使用 table 作为翻译表，对原字符串中的内容进行替换，而被映射为 None 的字符会被删除。

>>> '123中文'.translate(table1)
'ab3中文'
>>> '123中文'.translate(table2)
'ab3中文'
>>> '123中文'.translate(table3)
'ab3中文'
>>> '123中文'.translate(table4)
'ab3'

str.isspace()：判定字符串是否全为空格符；
str.isdigit()：判定字符串是否全为数字字符(汉字数字无法
识别)；
str.isnumeric()：判定字符串是否全为数字字符(汉字数字也可识
别)； #‟五‟.isnumeric()
str.isupper()：判定字符串是否全为大写字符；
„ERT‟.isupper()
str.isalpha()：判定字符串是否只包含字符，并且非空；
str.isalnum()：判断字符串是否只包含数字和字母，并且非空；
str.islower()：判定字符串是否全为小写字符；
str.istitle()：判定字符串的单词是否首字母大写；
str.count(char)：计算字符串中char字符的个数；
str.capitalize(): 将字符串的第一个字母大写；
str.wapcase(): 将字符串的字母大小写进行反转;
str(s)：返回任意类型s对应的字符串；
chr(u)：返回Unicode编码u对应的单个字符；
ord©：返回单个字符c对应的Unicode编码。
repr()：保留解释器的输出风格输出，适合eval函数得到原
来的对象。
print(repr(“Hello, \n \t \ world!”))

repr([1, 2, 3])
print(r’’)：保留原始字符串风格，功能和repr()方法类似，
但主要用于格式化输出中。
print(r‟ Hello, \n \t \ world!‟)

r’[1, 2, 3]’

字符串-格式化

format（）
方法接受位置参数和关键字参数，二者均传递到一个叫做replacement字段。而replacement字段在字符串内由大括号 { } 表示。

#未指定位置参数和关键字参数
print("{}{}{}".format("气球","飞","走了"))
#指定位置参数
print("{0}{1}{2}".format("气球","飞","走了"))
#指定关键字参数
print("{a}{b}{c}".format(a="大佬",b="带我",c="飞"))

格式化操作符 : %
当 % 的左右均为数字的时候，那么它表示求余数的操作；但当它出现在字符中的时候，他表示的是格式化操作符。
print() 函数使用以%开头的转换说明符对各种类型的数据进行格式化输出，具体请看下表。

#%c 格式化字符及其ASCII码

print('%c' % 'A')
print('%c' % 65)

#%o 格式化无符号八进制数

print('%#o'%10)#输出：0o12

#%X 格式化无符号十六进制数（大写）

print('%#X'%12)#输出：0XC

#%f 格式化浮点数字，可指定小数点后的精度

print('%f'%3.21)

数字

python中可以表示复数用j来表示虚部complex（a，b）函数可以形成复数
real查看实部 imag查看虚部 conjugate（）返回共轭复数

python中数字类型的变量可以表示任意大的数值

a=99999999999999
print(a**3)#a**3代表a*a*a

十六进制以0x开头，八进制以0o开头，二进制以0b开头

binary=0b101#二进制中的5
print(binary)
octal=0o17#八进制中的15
print(octal)
hexadecimal=0x1f#十六进制中的31
print(hexadecimal)

python中可以表示复数用j来表示虚部complex（a，b）函数可以形成复数。real查看实部 imag查看虚部 conjugate（）返回共轭复数

c1=2+3j
print(c1)
c2=complex(2,3)
print(c2)
print(c1+c2)
print(c2.real)#返回复数的实部
print(c2.imag)#返回复数的虚部
print(c2.conjugate())#返回复数的共轭复数

列表

列表是python的内置可变序列，是包含若干元素的有序连续内存空间，用[ ]表示，列表可以和元组，字典等嵌套使用，可以增加删除元素，列表对象自动进行内存的扩展与收缩
访问列表元素

访问列表元素 list[index]

fruits=['apple','banner','waterlemon']
#访问列表元素
print(fruits[0])#输出结果为：apple
print(fruits[1])
print(fruits[2])
print(fruits[-1])#输出结果为：waterlemon

修改元素

#fruits=['apple', 'banner', 'waterlemon']
fruits[2]="lemon"#根据索引修改元素
print(fruits)#输出结果为：['apple', 'banner', 'lemon']

添加元素 append() 和 inserted()

#fruits=['apple', 'banner', 'waterlemon']
fruits.append("grape")#直接在列表结尾添加元素
print("添加元素后"+str(fruits))#输出结果：添加元素后['apple', 'banner', 'lemon', 'grape']
fruits.insert(0,"pear")
print('插入元素后'+str(fruits))#指定索引插入元素：插入元素后['pear', 'apple', 'banner', 'lemon', 'grape']

删除元素 del list[index] 和 remove()和pop()

# ['pear', 'apple', 'banner', 'lemon', 'grape']
del fruits[0]#根据索引删除元素
print('删除元素后'+str(fruits))#输出结果：删除元素后['apple', 'banner', 'lemon', 'grape']
fruits.pop()#没有指定索引，默认弹出结尾元素
fruits.pop(0)#根据索引，弹出指定位置的元素
print('删除开头和结尾后'+str(fruits))#输出结果：删除开头和结尾后['banner', 'lemon']
fruits.remove("lemon")#根据值删除元素
print("删除lemon之后"+str(fruits))#输出结果：删除lemon之后['banner']

list中的方法

list.sort()
对列表进行永久性排序

animals = ['dog', 'pig', 'chick', 'bird', 'insect']
animals.sort()  # 对列表进行排序，默认按照Ascll编码进行排序
print('永久排序之后' + str(animals))#输出结果：永久排序之后['bird', 'chick', 'dog', 'insect', 'pig']
animals.sort(reverse=True)  # 设置与字母顺序相反的顺序
print('永久排序(倒转)之后' + str(animals))# 永久排序(倒转)之后['pig', 'insect', 'dog', 'chick', 'bird']

sorted(list)
对列表进行临时性排序

animals = ['dog', 'pig', 'chick', 'bird', 'insect']
# 对列表临时性排序
print("临时排序" + str(sorted(animals, reverse=True)))  #临时排序['pig', 'insect', 'dog', 'chick', 'bird']
print("临时排序之后" + str(animals))#临时排序之后['dog', 'pig', 'chick', 'bird', 'insect']

list.reverse()
对列表进行永久性倒转

animals = ['dog', 'pig', 'chick', 'bird', 'insect']
animals.reverse()
print("倒转列表之后" + str(animals))#列表中数据为：['human', 'chick', 'bird', 'insect']

len(list) 获取列表长度

animals = ['dog', 'pig', 'chick', 'bird', 'insect']
animals.insert(0,"human")
animals.pop(2)
animals.remove('dog')
print("列表中数据为："+str(animals))
print('列表长度为：'+str(len(animals)))#输出结果：4

操作列表

遍历整个列表

for language in  languages:
    print(language)
print("---------")
for i in range(0,3):
     print(languages[i])

输出结果：

创建数字列表 range()

 #使用函数range(offset,len) offset是起始下标，len代表要停止的值（不包括）
squares=[]
for value in range(1,4):
    print(value)
    squares.append(value**2)
print("-------")
for square in squares:
    print(square)
#range(offset,len,rise) rise是步长，即每次增长的数值(未指定默认是1)
print("-------")
for value in range(0,4,2):
    print(value)

#使用list()将range()的结果直接转换为列表
print("-------")
numbers=list(range(1,3))
print(str(numbers))
print(str(range(0,3)))
#对数字列表()进行简单的统计计算
print("-------")
numbers=range(1,4)
numList=list(numbers)#将range()转换为数字列表

输出结果：

使用列表的一部分

切片：指定要使用的第一个元素的索引和‘最后一个元素的索引加1’

切片：指定要使用的第一个元素的索引和‘最后一个元素的索引加1’
players=['joy','mary','john','honey']
print(players[0:3])
#没有第一个索引，从列表的开头开始
print(players[:3])
#没有第二个索引，从第一个索引开始到结尾
print(players[1:])
#负数索引也是可以的
print(players[-3:-1])
#遍历切片
for player in players[:3]:
    print(player.title())
#复制列表
print("--------")
#使用提前切片的方式，创建原始列表的副本，再将改副本存储到新列表中
my_foods=['pizza','cake','tomato']
# friend_foods= my_foods[0:len(my_foods)]
friend_foods=my_foods[:]
print(str(my_foods))
print(str(friend_foods))
my_foods.append("fish")
print(str(my_foods))
print(str(friend_foods))
#list1=list2不能得到两个表，两个列表名共用一个列表数据
print("---------")
my_sports=['PingPong','Basketball','football']
friends_sports=my_sports
print(str(my_sports))
print(str(friends_sports))
my_sports.append("my_foods")
print(str(my_sports))
print(str(friends_sports))

运行结果：

元组

Python将不能修改的值称为不可变的，而不可变的列表称为元组
元组看起来犹如列表，但使用圆括号而不是方括号来标识。
元组属于不可变序列，一旦创建，用任何方法都不能修改元素的值，也无法增加或删除元素
元组的创建与删除
元组的访问

#元组的访问
dimensions=(200,50)
print(dimensions)#(200, 50)
print(dimensions[0])#输出结果：200

元组的遍历

for dimension in  dimensions:
    print(dimension)

元组和列表的区别：
tuple（）是冻结列表使其不可变，list（）是融化元组使其可变，使用元组可以是代码数据更安全，如果元组中包含列表，情况略有不同

字典

字典是**“键值对”的无序可变序列**，键和值用冒号分隔，所有元素放在大括号中，键是不可变数据，不能用列表、集合、字典作为字典的键，这些是可变序列，键不允许重复，值可以重复。
一个简单的字典

alien_0={'color':'green','points':15}
print(alien_0['color'])#输出结果：green

字典的创建

预备知识：什么是 zip()函数？
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

• 从参数中的多个迭代器取元素组合成一个新的迭代器
• 返回：一个zip对象，其内部元素为元组；可以转化成列表或元组
• 传入参数：元组、列表、字典等迭代器

numbers={1,2,3,4,5}
letters={'a','e','i','o','u'}
#zip()的结果是 元组组成的列表
for element in zip(numbers,letters):
    print(element)
#输出结果：
#(1, 'o')
#(2, 'u')
#(3, 'i')
#(4, 'a')
#(5, 'e')    

字典的多种创建方式

#直接创建
a={'height':"12px",'width':"12px",'color':"red"}
#dict()根据已有的数据快速创建字典
numbers={1,2,3,4,5}
letters={'a','e','i','o','u'}
for element in zip(numbers,letters):#zip()的结果是 元组组成的列表
    print(element)

dic=dict(zip(numbers,letters))
print(dic)#输出结果：{1: 'u', 2: 'e', 3: 'i', 4: 'o', 5: 'a'}

#dict()根据给定的“键值对”来创建字典
life=dict(name = 'wd' ,age = 18)
print(life)#输出结果：{'name': 'wd', 'age': 18}
#给定内容为“键”，创建值为空的字典
fruit_prices=dict.fromkeys(['apple','pear','banana'])
print(fruit_prices)#输出结果：{'apple': None, 'pear': None, 'banana': None}
fruit_prices['apple']="￥3.98" 
print(fruit_prices)#输出结果：{'apple': '￥3.98', 'pear': None, 'banana': None}

多种读取方式

fruit_prices=dict.fromkeys(["apple",'pear','banner','watermelon'])
fruit_prices['apple']="￥3.98/斤"
fruit_prices['pear']="￥4.98/斤"
fruit_prices['banner']="￥6.00/斤"
fruit_prices['watermelon']='￥3.50/斤'
print(fruit_prices)#输出结果：{'apple': '￥3.98/斤', 'pear': '￥4.98/斤', 'banner': '￥6.00/斤', 'watermelon': '￥3.50/斤'}
#下表为键，通过键来获取对应值
for key in fruit_prices.keys():
    print(fruit_prices[key])
#输出结果：
# ￥3.98/斤
# ￥4.98/斤
# ￥6.00/斤
# ￥3.50/斤
print("-------")
#使用get（）方法访问键对应的值
print(fruit_prices.get('apple'))
#使用values()和keys()
print(fruit_prices.values())#输出结果为：dict_values(['￥3.98/斤', '￥4.98/斤', '￥6.00/斤', '￥3.50/斤'])
print(fruit_prices.keys())#输出结果为：dict_keys(['apple', 'pear', 'banner', 'watermelon'])
#items（）方法返回字典的“键值”对列表
print(fruit_prices.items())
#输出结果为：dict_items([('apple', '￥3.98/斤'), ('pear', '￥4.98/斤'), ('banner', '￥6.00/斤'), ('watermelon', '￥3.50/斤')]

字典元素的添加与修改

# 当以指定的‘键’为下标给字典赋值时，若键值存在，则表示修改值，若不存在，则表示添加一个键值对，添加一个新元素
numbers="12345"
letters="aeiou"
dictional=dict(zip(numbers,letters))
print(dictional)#输出结果：{'1': 'a', '2': 'e', '3': 'i', '4': 'o', '5': 'u'}
dictional['1']='A'
print(dictional)#输出结果：{'1': 'A', '2': 'e', '3': 'i', '4': 'o', '5': 'u'}
dictional['6']='Q'
print(dictional)#输出结果：{'1': 'A', '2': 'e', '3': 'i', '4': 'o', '5': 'u', '6': 'Q'}

# 使用update()方法是一次性将另一个字典的键值对全部添加到当前字典对象
dir1={1:'one',2:'two'}
dir2={3:'three',4:'four'}
dir1.update(dir2)
print(dir1)#输出结果：{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

集合

集合是无序可变序列，与字典一样使用一对大括号，同一个集合的元素之间不允许重复，集合中每一个元素都是唯一的
集合的创建与删除

a={1,3,5}#a就是一个集合
print(a)#输出结果：{1, 3, 5}

集合操作

a ={8,9,10,11,12,113}
b={3,4,5,6,7,8,9,10}
a | b     #并集 
{3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 113}
a.union(b)
{3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 113}
a & b       #交集
{8, 9, 10}
a.intersection(b)
{8, 9, 10}
a.difference(b)       #差集
{113, 11, 12}
a - b
{113, 11, 12}
a.symmetric_difference(b)     #对称差
{3, 4, 5, 6, 7, 11, 12, 113}
a ^ b
{3, 4, 5, 6, 7, 11, 12, 113}
a == b     #判断比较两个集合的大小
False
a.issubset(b)     #判断是否为子集
False