您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net:Python第一天自学

新葡亰496net:Python第一天自学

发布时间:2019-06-19 12:39编辑:奥门新萄京娱乐场浏览(79)

    python是一门动态解释型的强类型定义语言(先编写翻译后解释)

    python基础(str,list,tuple),pythontuple

    python是一门动态解释型的强类型定义语言(先编译后解释)

    动态类型语言

    动态类型的语言编制程序时,长久也不用给别的变量内定数据类型,该语言会在您首先次赋值给变量时,在内部将数据类型记录下来

    解释型

    程序每实践到源程序的某一条指令,则会有一个称为解释程序的外壳程序将源代码调换来二进制代码以供实行,总言之,正是无休止地演说、实行、解释、实施

    强类型

    假如三个变量被钦命了有个别数据类型,假设不通过强制转变,那么它就长久是其一数据类型了

    优点:效用高,团队开荒,移植,拓展,嵌入

    缺点:速度慢,无法加密,禁止四线程并行进程

    告诉解释器用什么样编码试行

    #!/usr/bin/env python # -*- coding: utf-8 -*- 进制 二进制  01 八进制  01234567 十进制  0123456789 十六进制  0123456789ABCDEF   注释 #单行注释 '''多行注释''' 用户输入:input('用户输入内容') 打字与印刷荧屏     name = 'sunlizhao'
      print('I am %s'%(name))   %s是字符串 %d是数字 %f是浮点型   数据类型 数字   int(整型),long(长整形),float(浮点型),complex(负数) 布尔   真或假, 1或0, true或false 字符串   name = 'sunlizhao'   print('I am %s'%(name))   %s是字符串 %d是数字 %f是浮点型   

    PyCharm 一些轻易常用设置操作
    安装模板
    File->Settings->Editor->File and Code Templates

    PyCharm 一些简便常用设置操作
    安装模板
    File->Settings->Editor->File and Code Templates

    Python第一天自学,变量,基本数据类型,python第一天

    PyCharm 一些简约常用设置操作
    安装模板
    File->Settings->Editor->File and Code Templates

    //切换python版本
    File->settings->Project interpreter ->选择版本

    #!use/bin/env python
    # -*- coding:utf-8 -*-  #设置utf-8编码
    var=1
    ca=2
    ca =var
    print(ca)
    #python 运算符基本均等

    #有五个不等运算符号,**意味着求幂 // 代表除取整
    # a**b a的b次方
    #9/2= 4.5 #python3 可以自行转成float类型
    # 9//2 =4

    字符串管理

    a=1 #宣称八个变量 值为1 动态变量 能够每一天更改换量类型
    b="abc你好" #概念二个字符串
    c="bc"
    print (b)
    ret="bc" in c #代表 字符串"bc" 是否在c 变量中 在true 不在false
    print (ret)

    主干数据类型:
    数字 int
    字符串 str
    布尔值 bool
    列表 list
    元组 tuple
    字典 dict

    type(ret) #type 重临该品种

    翻开对象的类,或所具有的功能

    temp="alex"
    t=type(temp)
    print(t)
    #str,ctr 鼠标左键,找到str类,内部有着的法子

    temp="alex"
    b=dir(temp) #飞速看看这几个类的享有办法

    着力数据类型常用效用

    a=1 #声澳优(Nutrilon)个变量 值为1 动态变量 可以每日更退换量类型
    b="abc你好" #概念一个字符串
    c="bc"
    print (b)
    ret="bc" in c #代表 字符串"bc" 是否在c 变量中 在true 不在false
    print (ret)

    temp="asd";

    print(type(temp));#能够获得到品种
    print(dir(temp));#能够高速获得项目标具备办法
    al="alex";
    ret=al.capitalize();#将第贰个字符形成大写
    print(ret);
    al="alex";
    ret=al.center(20,'*') #让字符串居中,两侧以钦赐字符填充,加上填充字符一共
    筹齐给定的数字长度,这里给定的是20,注意要钦定单个字符,不可能是字符串
    print(ret);

    al="alexaa"
    print(al.count('a'));#找出二个字符或字符串 在三个字符串出现的次数
    print(al.count("a",4));#招来一个字符或字符串 在二个字符串哪个地方然后现身
    的次数
    temp="hello"
    print(temp.endswith('o')) #认清二个字符串是或不是是以给定的字符或字符串结尾的
    print(temp.endswith('e',0,2)); #判别获得字符串里抢先等于0的岗位,小于2的
    职位 的最后字符
    print(temp.startswith(('h')));#认清是还是不是一个字符起首
    content="hellot999"
    print(content.expandtabs(20))#试验看下吧 就是把tab只怕t转换成20个空格

    print(content.__len__())#输出字符串长度
    s="hello 9999";
    print(s.find("h"));#给定字符搜索 在该字符串所在的职位,未有回来-1

    s="hello{0},age{1}" #python 也会有占位符
    print(s)
    new1=s.format('alex',19) #format能够给占位符赋值
    print(new1)
    a="alex9"
    print(a.isalnum())#认清字符是不是是数字和数字
    print(a.isalpha());#判别字符串是还是不是都以字母
    print(a.isdigit());#认清是还是不是都以数字
    print(a.islower());#判定是还是不是都以小写
    print(a.isspace());#认清是或不是是空格
    print(a.istitle())#剖断是或不是是标题,首字母大写
    print(a.isupper());#认清是还是不是都以大写
    li=["alex","eric"]
    s="-".join(li) #将列表,元组,或数组(有数组么?)以给定字符连接到一同
    print(s)
    print(s.ljust(20,'*'))#字符串左对齐,左边填充给定字符,也可不给定

    s=" alex "
    news = s.lstrip() # 移除右边的空格
    print(news)
    print(s.rstrip())#移除左边的空格
    print(s.strip())#移除左右两边空格
    s="alex sb alxx"
    ret=s.partition('sb') ##将字符串分割拆分 成多个元组
    print(ret)

    s="alex sb alxx"
    ret=s.replace("al","bb")##将字符串中的某个字符替换 重返新的字符串
    print(ret)

    s="alexalex"
    ret=s.split("e",1) #依据给定字符 将字符串分割成列表 能够加入第三个参数 分
    割几次
    print(ret)

     

    s="alexalex"
    print(len(s)) #能够博得字符串的尺寸
    print(s[0]) #依靠目录获取字符
    print(s[1])

    print(s[0:2]) # 切成丝 获取字符>=0 <2 以内的
    for temp in s:
    print(temp)

    ####列表####
    name_list=['a','bxs','ccc']
    #索引
    print(name_list[0])
    #切片
    print(name_list[0:2])
    #len
    print(name_list[0:len(name_list)])

    #for
    for i in name_list:
    print(i)

    #列表内部提供的功效
    #append追加

    name_list.append("dddd")
    name_list.append("dddd")
    name_list.append("dddd")
    print (name_list)
    ##count 查询一个因素在列表中个数
    num=name_list.count("dddd")
    print(num)

    ##extend 将一个列表插入到这么些列表后面部分
    temp=[11,22,113,33,44]

    name_list.extend(temp)

    print (name_list)

    ##index 查找列表中多少个成分 并再次回到她的目录下标
    index=name_list.index(11)
    print(index)

    ##insert 在那些列表钦定的下标地方插入多个因素 原下标地点然后元素向后移
    name_list.insert(1,'SB')

    print(name_list)

    ##pop 将列表中贰个要素(能够内定索引下标,私下认可不安装参数是终极三个)移除掉 并重临这几个成分

    a=name_list.pop(0);

    print (a)
    print(name_list)

    ##remove 移除钦定成分

    name_list.remove("SB")
    print(name_list)

    ##reverse 将列表元素翻转
    name_list.reverse();
    print(name_list)

    PyCharm 一些简易常用设置操作 设置模板 File-Settings-艾德itor-File and Code Templates //切换pytho...

    动态类型语言

    字符串操作:

    name.capitalize()       首字母大写 name.casefold()         大写全体大写 name.center(50,'-')     在name的两边输出  -  字符 name.count('s')          计算s出现的次数 name.encode()           字符编码为bytes格式 name.endswith('lz')     决断字符串是不是为lz结尾 'stlz'.expandtabs(10)    讲t调换为多少长度的空格 name.find('sl')               查找sl,找到重临其索引,  找不到再次回到-1

    format :
        >>> msg = "my name is {}, and age is {}"
        >>> msg.format("alex",22)
        'my name is alex, and age is 22'
        >>> msg = "my name is {1}, and age is {0}"
        >>> msg.format("alex",22)
        'my name is 22, and age is alex'
        >>> msg = "my name is {name}, and age is {age}"
        >>> msg.format(age=22,name="ale")
        'my name is ale, and age is 22'
    format_map
        >>> msg.format_map({'name':'alex','age':22})
        'my name is alex, and age is 22'
    

      num1 = [11,22,33] num2 = (11,22,33) #num3 = {'a' = 11, 'b' = 22, 'c' = 33}   myStr = 'hello word itcast and' #字符串操作 print (myStr) print(myStr.find("word"))#找不到重返-1,找到再次来到下标 print(myStr.rfind("itcast"))#从右边查找,重回下表 print(myStr.index('word'))#同find,找不到会出现至极print(myStr.rindex("itcast"))#同find   print(myStr.count('e'))#追寻出现的次数   print(myStr.replace('word','Word',1))#将word替换为Word(从左到右替换三个)   print(myStr.split(' '))#将字符串中的空格切割掉   print(myStr.capitalize())#字符串第一个字符大写 print(myStr.title())#首字母大写   print(myStr.lower())#负有大写字符转变为小写 print(myStr.upper())#有着小写字母转换为大写   lyric = " 想陪你一块看大海 " print(lyric.center(50))#在肆20个字符中居中 print(lyric.ljust(50))#靠左 print(lyric.rjust(50))#靠右   print(lyric.strip())#免去左右两侧空格 print(lyric.lstrip())#接头左臂空格 print(lyric.rstrip())#知晓左侧空格   print(lyric.partition("一齐"))#以'一同'为大旨分割成三段 print(lyric.rpartition("一同"))#从右侧初叶查找(元组)   file_name = "xxxx.txt" print(file_name.endswith(".txt"))#看清是不是是.txt为后缀 print(file_name.startswith("xxxx"))#判断是或不是是xxxx为开端   numbe = "q" print(numbe.is阿尔法())#判别是不是是字母 print(numbe.isdigit())#认清是或不是是数字 print(numbe.isalnum())#决断是还是不是是数字依旧字母   print(numbe.isspace())#看清是不是是纯空格   a = ["aa","bb","cc"] b = " " print(" ".join(a))#将a中的字符串用b连接起来    

    列表,元祖操作

    概念列表   names = ['孙礼昭','slz','sunlizaho']   下标从0开始names[0],names[1],names[2]   倒取从-1开始 names[-1],names[-2],names[-3] 切成丝:取多少个因素   步长为2   names[::2]    假若想取到倒数因素,不能够写-1   names[0:] 追加:   从最后增加   names.append('小编是新来的')  插入:   通过索引插入   names.insert(0,'小编是首先') 修改:   通过索引修改   names[0] = '作者才是率先' 删除:   强删list   def names   清空list   names.clear()   依据下标删除成分内容   def names[0]   names[0] = []   删除钦定元素  names.remove('slz')   删除列表最终二个值   names.pop() 拓展:   list1的剧情增加到names的前边   names.extend(list1) 总计:   总括names中slz出现的次数   names.count('slz') 排序/翻转:   依照ascll码排序,注意py3分歧数据类型不可能排序   names.sort()   将全体list倒序(不排只倒)   names.reverse() 获取下标:   依据成分内容得到下标(只回去找到的首先个)   names.index('slz')  元组:tuple一旦创造,不得涂改 t = (a,b,[c,d]) tt = t[2] tt[0] = e tt[1] = f print(tt) 不是说不能够变呢? 今后为啥又足以变了吧! tuple的不改变是指向不改变,指向的list不能够变,不过在那之中的内容是能够变动的            

     

      

     

     

    python是一门 动态解释型的强类型 定义语言(先编写翻译后解释) 动态类型语言 动态类型的言语编制程序时,永世也不...

    //切换python版本
    File->settings->Project interpreter ->选用版本

    //切换python版本
    File->settings->Project interpreter ->采取版本

    动态类型的语言编制程序时,长久也不用给别的变量钦定数据类型,该语言会在你首先次赋值给变量时,在里头将数据类型记录下来

    #!use/bin/env python
    # -*- coding:utf-8 -*-  #设置utf-8编码
    var=1
    ca=2
    ca =var
    print(ca)
    #python 运算符基本雷同

    #!use/bin/env python
    # -*- coding:utf-8 -*-  #设置utf-8编码
    var=1
    ca=2
    ca =var
    print(ca)
    #python 运算符基本一致

    解释型

    #有七个不等运算符号,**表示求幂 // 代表除取整
    # a**b a的b次方
    #9/2= 4.5 #python3 能够自动转成float类型
    # 9//2 =4

    #有多个不等运算符号,**表示求幂 // 代表除取整
    # a**b a的b次方
    #9/2= 4.5 #python3 能够自行转成float类型
    # 9//2 =4

    次第每实行到源程序的某一条指令,则会有贰个名为解释程序的外壳程序将源代码调换到二进制代码以供实践,总言之,就是无休止地解说、实行、解释、实践

    字符串管理

    字符串管理

    强类型

    a=1 #宣示贰个变量 值为1 动态变量 能够随时更换动量类型
    b="abc你好" #概念叁个字符串
    c="bc"
    print (b)
    ret="bc" in c #代表 字符串"bc" 是否在c 变量中 在true 不在false
    print (ret)

    a=1 #宣称三个变量 值为1 动态变量 能够随时更改动量类型
    b="abc你好" #概念三个字符串
    c="bc"
    print (b)
    ret="bc" in c #代表 字符串"bc" 是否在c 变量中 在true 不在false
    print (ret)

    举个例子多个变量被钦定了有些数据类型,假设不通过强制调换,那么它就长久是那么些数据类型了

    骨干数据类型:
    数字 int
    字符串 str
    布尔值 bool
    列表 list
    元组 tuple
    字典 dict

    基本数据类型:
    数字 int
    字符串 str
    布尔值 bool
    列表 list
    元组 tuple
    字典 dict

    亮点:效用高,团队支付,移植,拓展,嵌入

    type(ret) #type 重返该品种

    type(ret) #type 再次来到该项目

    症结:速度慢,不能加密,禁止十六线程并行进程

    翻开对象的类,或所负有的功能

    查阅对象的类,或所独具的效率

    报告解释器用什么样编码施行

    temp="alex"
    t=type(temp)
    print(t)
    #str,ctr 鼠标左键,找到str类,内部有着的章程

    temp="alex"
    t=type(temp)
    print(t)
    #str,ctr 鼠标左键,找到str类,内部装有的不二秘诀

    #!/usr/bin/env python

    temp="alex"
    b=dir(temp) #立刻看看这么些类的持有办法

    temp="alex"
    b=dir(temp) #飞速看看那一个类的装有办法

    # -*- coding: utf-8 -*-

    着力数据类型常用成效

    主导数据类型常用成效

    进制

    a=1 #声称三个变量 值为1 动态变量 能够随时改变动量类型
    b="abc你好" #概念多少个字符串
    c="bc"
    print (b)
    ret="bc" in c #代表 字符串"bc" 是否在c 变量中 在true 不在false
    print (ret)

    a=1 #声称贰个变量 值为1 动态变量 能够天天更换换量类型
    b="abc你好" #概念三个字符串
    c="bc"
    print (b)
    ret="bc" in c #代表 字符串"bc" 是否在c 变量中 在true 不在false
    print (ret)

    二进制  01

    temp="asd";

    temp="asd";

    八进制  01234567

    print(type(temp));#能够获得到品种
    print(dir(temp));#能够高速获得项指标具备办法
    al="alex";
    ret=al.capitalize();#将第叁个字符形成大写
    print(ret);
    al="alex";
    ret=al.center(20,'*') #让字符串居中,两侧以钦命字符填充,加上填充字符一共
    筹齐给定的数字长度,这里给定的是20,注意要钦点单个字符,不可能是字符串
    print(ret);

    print(type(temp));#可以拿走到项目
    print(dir(temp));#能够高速获得项目标富有办法
    al="alex";
    ret=al.capitalize();#将率先个字符形成大写
    print(ret);
    al="alex";
    ret=al.center(20,'*') #让字符串居中,两侧以内定字符填充,加上填充字符一共
    筹齐给定的数字长度,这里给定的是20,注意要内定单个字符,不可能是字符串
    print(ret);

    十进制  0123456789

    al="alexaa"
    print(al.count('a'));#新葡亰496net,寻觅三个字符或字符串 在叁个字符串出现的次数
    print(al.count("a",4));#追寻一个字符或字符串 在贰个字符串哪个地方然后出现
    的次数
    temp="hello"
    print(temp.endswith('o')) #看清一个字符串是不是是以给定的字符或字符串结尾的
    print(temp.endswith('e',0,2)); #剖断得到字符串里超越等于0的岗位,小于2的
    职位 的末尾字符
    print(temp.startswith(('h')));#认清是还是不是三个字符起头
    content="hellot999"
    print(content.expandtabs(20))#试验看下吧 正是把tab可能t转换成20个空格

    al="alexaa"
    print(al.count('a'));#找寻二个字符或字符串 在三个字符串出现的次数
    print(al.count("a",4));#寻觅三个字符或字符串 在贰个字符串哪个地点然后出现
    的次数
    temp="hello"
    print(temp.endswith('o')) #推断壹个字符串是不是是以给定的字符或字符串结尾的
    print(temp.endswith('e',0,2)); #看清获得字符串里超过等于0的职位,小于2的
    岗位 的结尾字符
    print(temp.startswith(('h')));#决断是或不是三个字符开头
    content="hellot999"
    print(content.expandtabs(20))#尝试看下吧 正是把tab也许t转换成20个空格

    十六进制  0123456789ABCDEF

    print(content.__len__())#输出字符串长度
    s="hello 9999";
    print(s.find("h"));#给定字符找寻 在该字符串所在的职位,未有回来-1

    print(content.__len__())#输出字符串长度
    s="hello 9999";
    print(s.find("h"));#给定字符寻觅 在该字符串所在的地方,未有回来-1

     

    s="hello{0},age{1}" #python 也许有占位符
    print(s)
    new1=s.format('alex',19) #format能够给占位符赋值
    print(new1)
    a="alex9"
    print(a.isalnum())#看清字符是还是不是是数字和数字
    print(a.isalpha());#决断字符串是还是不是都以字母
    print(a.isdigit());#看清是还是不是都是数字
    print(a.islower());#推断是或不是都以小写
    print(a.isspace());#看清是或不是是空格
    print(a.istitle())#判别是或不是是标题,首字母大写
    print(a.isupper());#认清是或不是都以大写
    li=["alex","eric"]
    s="-".join(li) #将列表,元组,或数组(有数组么?)以给定字符连接到一同
    print(s)
    print(s.ljust(20,'*'))#字符串左对齐,右侧填充给定字符,也可不给定

    s="hello{0},age{1}" #python 也许有占位符
    print(s)
    new1=s.format('alex',19) #format能够给占位符赋值
    print(new1)
    a="alex9"
    print(a.isalnum())#认清字符是不是是数字和数字
    print(a.isalpha());#推断字符串是还是不是都以字母
    print(a.isdigit());#认清是还是不是都以数字
    print(a.islower());#判定是或不是都以小写
    print(a.isspace());#认清是不是是空格
    print(a.istitle())#判定是或不是是标题,首字母大写
    print(a.isupper());#认清是不是都以大写
    li=["alex","eric"]
    s="-".join(li) #将列表,元组,或数组(有数组么?)以给定字符连接到一齐
    print(s)
    print(s.ljust(20,'*'))#字符串左对齐,左边填充给定字符,也可不给定

    注释

    s=" alex "
    news = s.lstrip() # 移除左侧的空格
    print(news)
    print(s.rstrip())#移除右侧的空格
    print(s.strip())#移除左右两边空格
    s="alex sb alxx"
    ret=s.partition('sb') ##将字符串分割拆分 成多个元组
    print(ret)

    s=" alex "
    news = s.lstrip() # 移除右侧的空格
    print(news)
    print(s.rstrip())#移除左侧的空格
    print(s.strip())#移除左右两边空格
    s="alex sb alxx"
    ret=s.partition('sb') ##将字符串分割拆分 成八个元组
    print(ret)

    #单行注释

    s="alex sb alxx"
    ret=s.replace("al","bb")##将字符串中的某个字符替换 重回新的字符串
    print(ret)

    s="alex sb alxx"
    ret=s.replace("al","bb")##将字符串中的有些字符替换 再次回到新的字符串
    print(ret)

    '''多行注释'''

    s="alexalex"
    ret=s.split("e",1) #依附给定字符 将字符串分割成列表 能够进入第叁个参数 分
    割几次
    print(ret)

    s="alexalex"
    ret=s.split("e",1) #依据给定字符 将字符串分割成列表 能够参预第四个参数 分
    割几次
    print(ret)

    用户输入:input('用户输入内容')

     

     

    打印显示器  

    s="alexalex"
    print(len(s)) #能够博得字符串的长短
    print(s[0]) #依赖目录获取字符
    print(s[1])

    s="alexalex"
    print(len(s)) #能够拿走字符串的长度
    print(s[0]) #依照目录获取字符
    print(s[1])

      name = 'sunlizhao'

    print(s[0:2]) # 切成丝 获取字符>=0 <2 之内的
    for temp in s:
    print(temp)

    print(s[0:2]) # 切块 获取字符>=0 <2 以内的
    for temp in s:
    print(temp)

      print('I am %s'%(name))

    ####列表####
    name_list=['a','bxs','ccc']
    #索引
    print(name_list[0])
    #切片
    print(name_list[0:2])
    #len
    print(name_list[0:len(name_list)])

    ####列表####
    name_list=['a','bxs','ccc']
    #索引
    print(name_list[0])
    #切片
    print(name_list[0:2])
    #len
    print(name_list[0:len(name_list)])

      %s是字符串 %d是数字 %f是浮点型

    #for
    for i in name_list:
    print(i)

    #for
    for i in name_list:
    print(i)

     

    #列表内部提供的功用
    #append追加

    #列表内部提供的效益
    #append追加

    数据类型

    name_list.append("dddd")
    name_list.append("dddd")
    name_list.append("dddd")
    print (name_list)
    ##count 查询多少个要素在列表中个数
    num=name_list.count("dddd")
    print(num)

    name_list.append("dddd")
    name_list.append("dddd")
    name_list.append("dddd")
    print (name_list)
    ##count 查询叁个因素在列表中个数
    num=name_list.count("dddd")
    print(num)

    新葡亰496net:Python第一天自学。数字

    ##extend 将多少个列表插入到那几个列表尾巴部分
    temp=[11,22,113,33,44]

    ##extend 将一个列表插入到这么些列表尾巴部分
    temp=[11,22,113,33,44]

      int(整型),long(长整形),float(浮点型),complex(负数)

    name_list.extend(temp)

    name_list.extend(temp)

    布尔

    print (name_list)

    print (name_list)

      真或假, 1或0, true或false

    ##index 查找列表中三个成分 并回到他的目录下标
    index=name_list.index(11)
    print(index)

    ##index 查找列表中二个成分 并回到他的目录下标
    index=name_list.index(11)
    print(index)

    字符串

    ##insert 在那几个列表钦赐的下标地点插入叁个因素 原下标地方然后元素向后移
    name_list.insert(1,'SB')

    ##insert 在这么些列表钦命的下标地点插入三个要素 原下标地点然后元素向后移
    name_list.insert(1,'SB')

      name = 'sunlizhao'

    print(name_list)

    print(name_list)

      print('I am %s'%(name))

    ##pop 将列表中八个成分(可以钦命索引下标,暗中认可不设置参数是最终二个)移除掉 并赶回那一个因素

    ##pop 将列表中二个要素(能够钦赐索引下标,暗中同意不安装参数是终极一个)移除掉 并回到那些元素

      %s是字符串 %d是数字 %f是浮点型

    a=name_list.pop(0);

    a=name_list.pop(0);

      

    print (a)
    print(name_list)

    print (a)
    print(name_list)

    字符串操作:

    name.capitalize()       首字母大写

    name.casefold()         大写全体大写

    name.center(50,'-')     在name的两边输出  -  字符

    name.count('s')          总括s出现的次数

    name.encode()           字符编码为bytes格式

    name.endswith('lz')     判定字符串是不是为lz结尾

    'stlz'.expandtabs(10)    讲t转变为多少长度的空格

    name.find('sl')               查找sl,找到重回其索引,  找不到重回-1

    format :
        >>> msg = "my name is {}, and age is {}"
        >>> msg.format("alex",22)
        'my name is alex, and age is 22'
        >>> msg = "my name is {1}, and age is {0}"
        >>> msg.format("alex",22)
        'my name is 22, and age is alex'
        >>> msg = "my name is {name}, and age is {age}"
        >>> msg.format(age=22,name="ale")
        'my name is ale, and age is 22'
    format_map
        >>> msg.format_map({'name':'alex','age':22})
        'my name is alex, and age is 22'
    

     

    num1 = [11,22,33]

    num2 = (11,22,33)

    #num3 = {'a' = 11, 'b' = 22, 'c' = 33}

     

    myStr = 'hello word itcast and'

    #字符串操作

    print (myStr)

    print(myStr.find("word"))#找不到重临-1,找到重临下标

    print(myStr.rfind("itcast"))#从右边查找,重临下表

    print(myStr.index('word'))#同find,找不到会出现十分

    print(myStr.rindex("itcast"))#同find

     

    print(myStr.count('e'))#追寻出现的次数

     

    print(myStr.replace('word','Word',1))#将word替换为Word(从左到右替换三个)

     

    print(myStr.split(' '))#新葡亰496net:Python第一天自学。将字符串中的空格切割掉

     

    print(myStr.capitalize())#字符串第二个字符大写

    print(myStr.title())#首字母大写

     

    print(myStr.lower())#不无大写字符调换为题写

    print(myStr.upper())#全部小写字母转变为题写

     

    lyric = " 想陪您一块看大海 "

    print(lyric.center(50))#在肆十四个字符中居中

    print(lyric.ljust(50))#靠左

    print(lyric.rjust(50))#靠右

     

    print(lyric.strip())#扫除左右两侧空格

    print(lyric.lstrip())#明白左臂空格

    print(lyric.rstrip())#知晓右边空格

     

    print(lyric.partition("一起"))#以'一齐'为骨干分割成三段

    print(lyric.rpartition("一起"))#从左侧初始查找(元组)

     

    file_name = "xxxx.txt"

    print(file_name.endswith(".txt"))#决断是或不是是.txt为后缀

    print(file_name.startswith("xxxx"))#认清是否是xxxx为始发

     

    numbe = "q"

    print(numbe.isalpha())#判定是不是是字母

    print(numbe.isdigit())#推断是不是是数字

    print(numbe.isalnum())#看清是不是是数字照旧字母

     

    print(numbe.isspace())#推断是不是是纯空格

     

    a = ["aa","bb","cc"]

    b = " "

    print(" ".join(a))#将a中的字符串用b连接起来

     

     

    列表,元祖操作

    概念列表

      names = ['孙礼昭','slz','sunlizaho']

      下标从0开始names[0],names[1],names[2]

      倒取从-1开始 names[-1],names[-2],names[-3]

    切开:取四个成分

      步长为2

      names[::2] 

      假诺想取到最终二个要素,不可能写-1

      names[0:]

    追加:

      从最后增添

      names.append('笔者是新来的') 

    插入:

      通过索引插入

      names.insert(0,'作者是首先')

    修改:

      通过索引修改

      names[0] = '作者才是率先'

    删除:

      强删list

      def names

      清空list

      names.clear()

      依据下标删除成分内容

      def names[0]

      names[0] = []

      删除钦赐成分

      names.remove('slz')

      删除列表最终一个值

      names.pop()

    拓展:

      list1的内容增加到names的后边

      names.extend(list1)

    统计:

      总计names中slz现身的次数

      names.count('slz')

    排序/翻转:

      依据ascll码排序,注意py3分歧数据类型无法排序

      names.sort()

      将全数list倒序(不排只倒)

      names.reverse()

    赢得下标:

      依照成分内容获取下标(只回去找到的首先个)

      names.index('slz')

     元组:tuple一旦成立,不得修改

    t = (a,b,[c,d])

    tt = t[2]

    tt[0] = e

    tt[1] = f

    print(tt)

    不是说不可能变呢? 现在为何又能够变了吗!

    tuple的不改变是指向不改变,指向的list无法变,不过中间的剧情是能够变动的

     

     

     

     

     

     

     

      

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    ##remove 移除钦定成分

    ##remove 移除钦命成分

    name_list.remove("SB")
    print(name_list)

    name_list.remove("SB")
    print(name_list)

    ##reverse 将列表元素翻转
    name_list.reverse();
    print(name_list)

    ##reverse 将列表成分翻转
    name_list.reverse();
    print(name_list)

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net:Python第一天自学

    关键词: