python学习

x = "I love Fish"
x.capitalize()#将首字母大写
'I love fish'
x
'I love Fish'#字符串并不变，字符串不能修改
x.casefold ()#都变成小写，不止英语
'i love fish'
x.title()
'I Love Fish'#每个单词首字母大写
x.swapcase()#大小写字母反转
'i LOVE fISH'
x.upper()#变成大写
'I LOVE FISH'
x.lower()#变成小写，只适用于英语
'i love fish'
###
x = "有内鬼，停止交易"
x.center(5)
'有内鬼，停止交易'
x.center(15)
'    有内鬼，停止交易   '
x.ljust(15)
'有内鬼，停止交易       '
x.rjust(15)
'       有内鬼，停止交易'
x.center(15,"淦")
'淦淦淦淦有内鬼，停止交易淦淦淦'
x.ljust(15,"淦")
'有内鬼，停止交易淦淦淦淦淦淦淦'
x.rjust(15,"淦")
'淦淦淦淦淦淦淦有内鬼，停止交易'
x.zfill(15)
'0000000有内鬼，停止交易'
"123".zfill(5)
'00123'
"-123".zfill(5)
'-0123'
###字符串查找
x = "上海自来水来自海上"
x.count("海")
2
x.count("海",0,5)
1
x.count("海",0,5)
1
x.find("海")
1
x.rfind("海")
7
x.rfind("鬼")
-1
###字符串替换：replace（old,new,count=-1）
"你好，在哪？".replace("你好","您好")
'您好，在哪？'
#translate(table)
table = str.maketrans("ABCDEFG","1234567")##将ABCDEFG分别换成1234567
"I love FishC".translate(table)
'I love 6ish3'##F和C分别替换成了6和3
###
x.startswith("我")
True
x.startswith("小甲鱼")
False
x.startswith("爱")
False
x.startswith("爱",1)##从下标为1开始第一个为“爱”
True
###判断大小写
x = "I love Python"
x.upper()
'I LOVE PYTHON'
x = "I love Python"
x.isupper()
False
x.isalpha()
False
"IlovepPython".isalpha()
True
r"I love Python\n".isprintable()
True
"I love Python".isprintable()
True
x = "1234"
x.isdigit()
True
x.isnumeric()
True
x.isdecimal()
True
x = "一二三四"
x.isdigit()
False
x.isnumeric()
True
x.isdecimal()
False
"I love Python".isidentifier()
False
"I_love_Python".isidentifier()
True
import keyword##导入判断是否为关键字函数
keyword.iskeyword("if")
True
keyword.iskeyword("py")
False
###
"   左侧不要留白".lstrip()
'左侧不要留白'
"左侧不要留白".lstrip("左")
'侧不要留白'

s = [1,2,3]
t = [4,5,6]
s + t返回[1,2,3,4,5,6]
t * 3返回[4,5,6,4,5,6,4,5,6]

###（1）嵌套列表
matrix = [[1,2,3],
          [4,5,6],
          [7,8,9]]
#访问嵌套列表（迭代一层列表用一层循环，迭代嵌套列表用嵌套循环）：
for i in matrix:
    for each in i:
        print(each)

        
1
2
3
4
5
6
7
8
9
#一个下标代表第一行
matrix[0]返回[1,2,3]
#两个下标代表行和列
matrix[0][0]返回1

for i in matrix:
    for each in i:
        print(each,end='')                #end=' '是每个元素以空格结尾
    print()                               #print（）默认每个循环后换行

#返回下面:   
123
456
789      #for i in matrix是锁定嵌套列表的每一个列表，for each in i是锁定嵌套列表中的每一个元素
###
lists = [[]]*3
lists
[[],[],[]]                 #相当于是这种嵌套列表lists=[
                           #                         [],
                           #                         [],
                           #                         []]
lists[0].append(3)
lists
[[3], [3], [3]] #只对第一行添加一个元素3，但因为*3复制来得三个还是引用用一个列表，所以都添加了3


A = [None]*3                #A是一个列表类型，并且将里面的元素复制三次
A
[None, None, None]
for i in range(3):
    A[i] = [None]*2        #A是一个一个列表，并且A的元素也是列表

    
A
[[None, None], [None, None], [None, None]]
####（2）下面三种：只有幅值是引用，后两种copy和切片是浅拷贝是对整个列表对象的复制
###第一种
x = [1,2,3]
y = x
x[1] = 1
x
[1, 1, 3]
y
[1, 1, 3]##y是引用x
###第二种
x = [1,2,3]
y = x.copy()
y
[1, 2, 3]
x
[1, 2, 3]
x[1] = 1
y
[1, 2, 3]#y就不是对x引用而是对整个列表对象的拷贝，改变x元素,不会i影响y元素
###第三种
x = [1,2,3]
y = x[:]    #切片
x
[1, 2, 3]
y
[1, 2, 3]
x[1] = 1
y            #切片同copy一样不仅仅是引用，改变x元素不会影响y
[1, 2, 3]

###（3）对于嵌套列表上面三种理解有所不同
###对于浅拷贝反而改变x,y也变了，这是因为浅拷贝只是拷贝了外层对象内层还是引用：
x = [[1,2,3],[4,5,6],[7,8,9]]
y = x.copy()
x[0][0] = 0
x
[[0, 2, 3], [4, 5, 6], [7, 8, 9]]
y
[[0, 2, 3], [4, 5, 6], [7, 8, 9]]
###深拷贝：（简单理解为浅拷贝是一个物体有两个名字，而深拷贝是两个完全一样的物体）
import copy##导入copy模块，copy模块有两个函数，其中.copy（）是浅拷贝，.deepcopy（）是深拷贝
x = [[1,2,3],[4,5,6],[7,8,9]]
y = copy.copy(x)#利用copy模块的copy函数，其中x为参数，这是浅拷贝
x[0][0] = 0
y
[[0, 2, 3], [4, 5, 6], [7, 8, 9]]##改变x也改变y，这是浅拷贝

x = [[1,2,3],[4,5,6],[7,8,9]]
y = copy.deepcopy(x)            ###这是深拷贝
x[0][0] = 0
y
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]###深拷贝，改变x不改变y

x = "123"
y = "123"
x is y
True        

x = [1,2,3]
y = [1,2,3]
x is y
False            #对于列表即便一样​​​​​​​，python也为他们存放了不同的列表中

###（1）例如
x = [1,2,3,4]
x = [i+1 for i in x]
x
[2, 3, 4, 5]
###例如（2）
x = [i*2 for i in "fish"]
x
['ff', 'ii', 'ss', 'hh']
###
code = [ord(i) for i in "FishC"]##调用ord内置函数，将单个字符串转换为对应编码
code
[70, 105, 115, 104, 67]
###例如（3）
a = [[1,2,3],
     [4,5,6],]
b = [x[1] for x in a]###获得每一行第二个元素
b
[2, 5]
###例如（4）
s = [[0]*3 for i in range (3)]
s
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]##i不管是多少都输出常量函数[0]*3,有意义地执行了几次i
###例如（4）
even = [i for i in range(10) if i % 2 == 0]
even
[0, 2, 4, 6, 8]
###例如（5）
word = ["Fantastic","Fish","Great"]
fwords = [w for w in word if w[0] == 'F']##w是一个字符串
fwords
['Fantastic', 'Fish']

#循环是通过迭代逐个修改列表中元素，而列表推导式是重新创建一个列表再赋值给原先的变量名

###下面对于嵌套：例如（1）
matrix = [[1,2,3],[4,5,6],[7,8,9]]
flatten = [col for row in matrix for col in row]
flatten
[1, 2, 3, 4, 5, 6, 7, 8, 9]#降维，相当于前面for row in matrix为外层循环，for col in row内层

###元组（1）
s = 1,2,3        #逗号把元素分开
t = 4,5,6
w = s,t           #逗号是构成元组的基本元素
w
((1, 2, 3), (4, 5, 6))
###（2）元组可生成列表
s = (1,2,3)
[each*2 for each in s ]    ###利用列表推导是可由元组生成列表
[2, 4, 6]
###（3）加了逗号才是元组
x = (123)
type(x)
                #不加逗号这是一个整数类型
x = (123,)
type(x)                    #关键字x看是什么类型
            #加了逗号才是元组类型
###打包和解包不仅适用于元组，也适用于列表和字符串
t = (123,"fish",3.14)
t
(123, 'fish', 3.14)#元组打包
(x,y,z) = t
x
123
y
'fish'
z
3.14        #元组解包
#
t = [123,"fish",3.14]
t
[123, 'fish', 3.14]#列表打包
[x,y,z] = t
x
123
y
'fish'
z
3.14#列表解包
###元组虽然不可变，但是元组中的元素指向可变的列表依然是可以变的
w = ([1,2,3],[4,5,6])
w[0][0] = 0
w
([0, 2, 3], [4, 5, 6])

class Turtle:##定义一个类
    head = 1#属性
    eyes = 2#属性
    legs = 4#属性
    shell = True#属性
    def crawl(self):#方法
        print("人们总是抱怨我动作慢吞吞的，殊不知不积跬步无以至千里的道理")
    def run(self):#方法
        print("虽然我行动很慢，但如果遇到危险，还是会拼命狂奔")
    def bite(self):#方法
        print("人善被人欺，鬼善被鬼骑，我可是会咬人的")
    def eat(self):#方法
        print("谁知盘中餐粒粒皆辛苦，吃得好不如吃得饱")
    def sleep(self):#方法
        print("Zzzz...")
#
= RESTART: C:/Users/lenovo/AppData/Local/Programs/Python/Python310-32/TingKe.py
t1 = Turtle()##调用函数，t1为Turtle类的对象（也叫实例对象）
t1.head#属性
1
t1.legs
4
t1.run()##方法要加（）
虽然我行动很慢，但如果遇到危险，还是会拼命狂奔
t2 = Turtle()##t2为另一个Turtle类对象
t2.head = 3
t2.head
3
t1.head
1#修改t2对象属性不会改变t1
t1.mouth = 1#动态地添加属性
t1.mouth
1
dir(t1)#用dir函数查看t1里面比t2多了mouth属性
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bite', 'crawl', 'eat', 'eyes', 'head', 'legs', 'mouth', 'run', 'shell', 'sleep']

type(t1)
#例如这是刚才定义的Turtle类的实例对象
x = 123
type(x)
#例如这是整数类的实例对象，不是一般的BIF（内置函数）
y = "fish"
type(y)
#例如这是字符串类的一个实例对象，不是一般的BIF（内置函数）