澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

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

2019-06-08 作者:www.8455.com   |   浏览(52)

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

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

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

动态类型语言

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

解释型

先后每实行到源程序的某一条指令,则会有2个叫做解释程序的外壳程序将源代码调换来二进制代码以供实践,总言之,就是不断地表明、推行、解释、实践

强类型

假设一个变量被钦定了某些数据类型,假若不经过强制转变,那么它就永恒是以此数据类型了

可取:成效高,团队费用,移植,拓展,嵌入

缺陷:速度慢,无法加密,禁止二十多线程并行进程

告知解释器用怎么着编码实施

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

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

Python第2天自学,变量,基本数据类型,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 #python三 能够自动转成float类型
# 9//2 =4

字符串管理

a=1 #扬言1个变量 值为1 动态变量 能够每二2日更改换量类型
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 #宣称3个变量 值为一 动态变量 能够随时更退换量类型
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,'*') #让字符串居中,两侧以钦定字符填充,加上填充字符1共
筹齐给定的数字长度,这里给定的是20,注意要内定单个字符,不可能是字符串
print(ret);

al="alexaa"
print(al.count('a'));#寻找二个字符或字符串 在3个字符串出现的次数
print(al.count("a",4));#搜索一个字符或字符串 在多少个字符串哪个地方然后出现
的次数
temp="hello"
print(temp.endswith('o')) #判定三个字符串是或不是是以给定的字符或字符串结尾的
print(temp.endswith('e',0,2)); #看清得到字符串里抢先等于0的职位,小于二的
岗位 的终极字符
print(temp.startswith(('h')));#判别是还是不是3个字符先导
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') ##将字符串分割拆分 成1个元组
print(ret)

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

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

 

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

print(s[0:2]) # 切成条 获取字符>=0 <贰 以内的
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 在那么些列表钦赐的下标地方插入3个因素 原下标地方然后成分向后移
name_list.insert(1,'SB')

print(name_list)

##pop 将列表中3个要素(能够内定索引下标,私下认可不安装参数是终极二个)移除掉 并再次回到这些成分

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-Editor-File and Code Templates //切换pytho...

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

动态类型语言

字符串操作:

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"))#找不到重回-一,找到重回下标 print(myStr.rfind("itcast"))#从右侧查找,再次来到下表 print(myStr.index('word'))#同find,找不到会出现非常print(myStr.rindex("itcast"))#同find   print(myStr.count('e'))#探索出现的次数   print(myStr.replace('word','Word',一))#将word替换为Word(从左到右替换1个)   print(myStr.split(' '))#将字符串中的空格切割掉   print(myStr.capitalize())#字符串第柒个字符大写 print(myStr.title())#首字母大写   print(myStr.lower())#享有大写字符调换为小写 print(myStr.upper())#具有小写字母转变为大写   lyric = " 想陪您一齐看大海 " print(lyric.center(50))#在53个字符中居中 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]    倘若想取到最后三个因素,无法写-一   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() 拓展:   list一的原委加多到names的前面   names.extend(list1) 计算:   总计names中slz出现的次数   names.count('slz') 排序/翻转:   依据ascll码排序,注意py三不相同数据类型不能够排序   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版本
基本数据类型,Python第一天自学。File->settings->Project interpreter ->选用版本

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

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

#!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 #python三 能够自行转成float类型
# 9//2 =4

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

次第每实行到源程序的某一条指令,则会有贰个称得上解释程序的外壳程序将源代码调换来②进制代码以供推行,总言之,正是不断地表明、执行、解释、执行

字符串管理

字符串处理

强类型

a=1 #声美素佳儿(Friso)个变量 值为一 动态变量 能够每日更改动量类型
b="abc你好" #概念3个字符串
c="bc"
print (b)
ret="bc" in c #代表 字符串"bc" 是否在c 变量中 在true 不在false
print (ret)

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

假如1个变量被钦定了有个别数据类型,假设不通过强制转变,那么它就永恒是其①数据类型了

宗旨数据类型:
数字 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类,内部有着的不2秘技

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你好" #概念1个字符串
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'));#寻找2个字符或字符串 在二个字符串出现的次数
print(al.count("a",4));#查找叁个字符或字符串 在3个字符串哪个岗位然后出现
的次数
temp="hello"
print(temp.endswith('o')) #看清3个字符串是或不是是以给定的字符或字符串结尾的
print(temp.endswith('e',0,2)); #认清获得字符串里超越等于0的任务,小于二的
位置 的末梢字符
print(temp.startswith(('h')));#看清是不是二个字符初叶
content="hellot999"
print(content.expandtabs(20))#实验看下吧 正是把tab或许t转换成20个空格

al="alexaa"
print(al.count('a'));#找出二个字符或字符串 在一个字符串出现的次数
print(al.count("a",4));#搜寻3个字符或字符串 在3个字符串哪个岗位然后出现
的次数
temp="hello"
print(temp.endswith('o')) #判别3个字符串是或不是是以给定的字符或字符串结尾的
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"));#给定字符搜索 在该字符串所在的岗位,未有回去-一

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

 

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) #依据给定字符 将字符串分割成列表 能够参加第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 <二 以内的
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)

数字

##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 查找列表中1个要素 并赶回她的目录下标
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,找到重回其索引,  找不到再次回到-一

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))#在四17个字符中居中

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()

拓展:

  list一的开始和结果加多到names的背后

  names.extend(list1)

统计:

  总计names中slz现身的次数

  names.count('slz')

排序/翻转:

  根据ascll码排序,注意py三差别数据类型无法排序

  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)

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:基本数据类型,Python第一天自学

关键词: