1 .定义变量加if
total = [ 'item_one' ,'item_two' ,'item_three' ,
'item_four' ,'item_five' ]
或者: ha = 'hahaha' \
'hahaha'
name = 'xuexiaoqiang' --定义变量
if True: --如果定义正确
print( name) --打印变量内容( 调用变量不能加"" ,'' 否则不会调用)
else:
print( "no" ) --否则打印no:,py对于格式的要求比较严格.必须对齐
2 .基础知识
` 案例` = '字符串'
setnece = '这是一个句子'
paragraph = '这是一个段落'
print( world+setnece,paragraph) ; print( '\n' )
str = '123456789'
print( str)
print( str[ 0 :-1] )
print( str[ 0 ] )
print( str[ 0 :5] )
print( str[ 3 :] )
print( str * 2 )
print( str + '你好' )
print( '-------------------------------------------' )
print( 'hello\nnihao' )
3 .字符串
import sys; x = 'randoy' ; sys.stdout.write( x + '\n' )
1 . stdout只能输出字符串，如果要输出数字，也需要先转成字符串形式的；print可以直接输出各种类型。
2 . stdout输出结果后不自动换行；print会自动换行。
3 . print默认调用了sys.stdout.write( ) 方法将输出打印到控制台，也可通过file参数将输出打印到其他文件中
print
` 案例` = 'a'
y = 'b'
print( x * 2 )
print( y +"哈哈" )
print( '----------------' )
print( x,end= " " )
print( y,end= " " )
print( " " )
4 .模块导入
在 python 用 import 或者 from.. .import 来导入相应的模块。
将整个模块( somemodule) 导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
` 案例` import sys
print( '===Python import mode===' )
print( '命令参数为:' )
for i in sys.argv:
print( i)
print( '\n python 路径为' ,sys.path)
from sys import argv,path
print( '-----' )
print( 'path:' ,path)
编码规范
1 .基本数据类型
` 案例` = 100 --int( 整形) || counter,miles,name = 100,1000 .0,'rundob'
miles = 1000.0 --fload( 浮点型)
name = "rundob" --字符串
print( counter,type( counter)) ; print( miles,type( miles)) --; 不换行输出指令,打印出前俩个变量的内容和类型
print( "准备进行运算" )
if True: --如果上方结果为真
sum1 = counter * 2 +miles%10+200 --定义sum1= var( 1 ) ×2+var( 2 ) 的值,和10取余+200
print( sum1)
else:
print( name,type( name))
2 .标准数据类型
不可变数据( 3 个) :Number（数字）、String（字符串）、List（列表）
可变数据( 3 个) :Tuple（元组）、Set（集合）、Dictionary（字典）
3 .标准数据类型拓展
python中支持: int、float、bool、complex（复数）
` 案例` = 1,2 .3,True,"asdasd+"
print( a,type( a) ,b,type( b) ,c,type( c) ,d,type( d))
if True:
print( "ok" ,"成功" )
用isinstance来判断:
haha = 123
print( isinstance( haha, int))
if True:
print( type( haha))
type( ) 不会认为子类是一种父类类型。
isinstance( ) 会认为子类是一种父类类型。
` 案例` ( self,x,y) :
self.x = x
self.y = y
class B( A) :
print ( isinstance( A( 1,2 ) ,A))
print( type( A( 1,2 )) == A)
print( isinstance( B( 1,2 ) ,A))
print( type( B( 1,2 )) == A)
结果：
True
True
True
False
` 案例` ( issubclass( bool,int))
print( True == 1 )
print( False == 0 )
print( True + 1 )
print( False + 1 )
print( 1 is True)
print( 0 is False)
4 .del语法
var1 = 10
print( var1+100)
del var1
var1 = 100
print( var1)
1 .python可以直接进行运算,无需shell中的let (( )) 等
print( 5 + 4 )
print( 5 - 4 )
print( 5 * 4 )
print( 5 / 4 )
print( 5 // 4 )
print( 5 % 4 )
print( 5 ** 4 )
print( -0 * 1 )
9
1
20
1.25
1
1
625
1 .Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数。实例如下：
# coding:utf-8
str = "RanDo"
print(str)
print(str[0:-1]) ##输出第一个字符到倒数第二个字符
print(str[1:3]) ##输出第二个
print(str[2:]) ##输出str变量第三个字符到末尾
print(str+"str") ##输出str变量内容+str
print(str*2) ##输出变量字符串俩次
2.Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：
# coding:utf-8
print("haha\nnima")
haha
nima
print(r"haha \n haha")
haha \n haha
3.反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 ' ''...' '' 跨越多行。
注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串
# coding:utf-8
word = "python"
print(word[0],word[-1]\
,word[0:-3],word[-5:-3])
#Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = ' m' 会导致错误。
1 .List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [ ] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下：
变量[ 头下标:尾下标]
` 案例` 0 为开始值，-1 为从末尾的开始位置。
t = [ 'a' ,'b' ,'c' ,'d' ,'e' ]
索引: 0 1 2 3 4
-5 -4 -3 -2 -1
list = [ 'abc' ,786,2.23,'rundon' ,70.2 ]
tinylist = [ 123 ,'rundon' ]
print( list)
print( list[ 0 ] ) --打印列表的第一个元素值.索引为0的值也就是abc
print( list[ 0 :-3] )
print( list[ 1 :] )
print( list+tinylist)
list = [ 123 ,'hah' ,0.1,'name' ]
list[ 0 ] = 9
list[ 1 :4] = [ 10 ,11 ,12 ,13 ]
print( list)
list[ 4 ] = ""
print( list)
[ 9 , 10 , 11 , 12 , 13 ]
[ 9 , 10 , 11 , 12 , '' ]
2 .Python列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2 （间隔一个位置）来截取字符串：
def reversWords( input) :
inputWords = input.split( "=" )
inputWords = inputWords[ -1::-1]
output = ',' .join( inputWords)
return output
rw = reversWords( input( "输入你要的数字:" ))
print( rw)
输入你要的数字:1= 2 = 3 = 4 = 5
5,4 ,3,2,1
1 .元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 ( ) 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同：
tuple = ( 'abc' ,123,0. 1 ,'haha' )
print( tuple)
print( tuple[ 0 :-1] )
print( tuple[ -1::-1] )
print( tuple[ 0 ::2] )
( 'abc' , 123 , 0.1 , 'haha' )
( 'abc' , 123 , 0.1 )
( 'haha' , 0.1 , 123 , 'abc' )
( 'abc' , 0.1 )
2 .虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则
string、list 和 tuple 都属于 sequence（序列）。
"" "
字符串、列表、元组都是序列类型
支持索引、切片、遍历
"" "
"" "
元组tuple
一种类似列表的数据序列类型
不可变，不可以添加、删除、更新元素
用两个小括号包括，元素之间用逗号分隔
"" "
问题：既然元组和列表这么像，为什么要有这个数据结构，需要元组的地方都用列表不就行了吗？
1 .内容区别
元组是异质( 一个元组内可存储不同数据类型的数值) 、不同类型而列表是同质，相同类型。
2 .使用区别
元组更多用于拆包，列表用于循环遍历。元组pack和unpack：
3 .是否可变
元组内容不可变，列表内容可变。
1 .集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set( ) 函数创建集合，注意：创建一个空集合必须用 set( ) 而不是 { } ，因为 { } 是用来创建一个空字典。
创建格式：
parame = { value01,value02,.. .}
或者
set( value)
` 案例` = { 'Google' ,'taobao' ,'Runnob' ,'Facebook' ,'zhizu' ,'Baidu' }
search = input( "输入你要查询的内容:" )
if search in sites :
print( f'{search} is in the sites' )
exit( 0 )
else:
print( f'{search} is not in the sites' )
exit( 2 )
` 案例2-集合运算` = set( '我爱你呀' )
b = set( '我恨你呀' )
print( a)
print( a - b )
print( a | b )
print( a & b )
print( a ^ b )
{ '你' , '爱' , '呀' , '我' }
{ '爱' }
{ '你' , '爱' , '我' , '呀' , '恨' }
{ '你' , '呀' , '我' }
{ '爱' , '恨' }
1 .字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用{ } 标识，它是一个无序的键( key) :值( value) 的集合。
键( key) 必须使用不可变类型。
在同一个字典中，键( key) 必须是唯一的。
` 案例` = { }
dict[ 'one' ] = "1-*****"
dict[ 2 ] = "2-哈拉少"
tinydict = { 'name' : 'rando' ,'code' :1,'site' : 'www.baidu.com' }
print( dict[ 'one' ] )
print( dict[ 2 ] )
print( dict.keys( ))
print( dict.values( ))
print( tinydict.keys( ))
print( tinydict.values( ))
2 .构造函数 dict( ) 可以直接从键值对序列中构建字典如下
print( dict( [ ( 'Runoob' ,1) ,( 'Google' ,2) ,( 'Taobao' ,3) ] ))
print( { x: x**2 for x in range ( 11 ) } )
print( dict( Runoob= 1 ,Google= 2 ,Taobao= 3 ))
另外，字典类型也有一些内置的函数，例如 clear( ) 、keys( ) 、values( ) 等。
注意：
1 、字典是一种映射类型，它的元素是键值对。
2 、字典的关键字必须为不可变类型，且不能重复。
3 、创建空字典使用{ } 。
1 .有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
2 .Python 数据类型转换可以分为两种：
` 隐式类型转换 - 自动完成` = 3
num_flo = 2.5
num_new = num_int + num_flo
print( num_new,type( num_new))
--较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。( 隐式类型转换)
` 显式类型转换 - 需要使用类型函数来转换` ( ) 、float( ) 、str( ) 等预定义函数来执行显式类型转换。
code:
x = 123
x1 = '123'
x2 = 3.8
print( type( x) ,type( x1) ,type( x2))
x1_1 = int( '123' )
print( x1_1,type( x1_1))
x2_2 = int( 3.8 )
print( x2_2,type( x2_2))
x_0 = float( 123 )
print( x_0,type( x_0))
< class 'int' > < class 'str' > < class 'float' >
123 < class 'int' >
3 < class 'int' >
123.0 < class 'float' >
1 .Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
Python支持各种数据结构的推导式：
列表( list) 推导式
字典( dict) 推导式
集合( set) 推导式
元组( tuple) 推导式
1 .列表推导式格式为：
[ 表达式 for 变量 in 列表]
[ out_exp_res for out_exp in input_list]
或者
[ 表达式 for 变量 in 列表 if 条件]
[ out_exp_res for out_exp in input_list if condition]
或
[ 表达式 for 变量 in 序列]
让变量去序列中取值，每取一个值就创建列表中的一个元素，元素的值就是表达式的值
for 变量 in 序列：
产生元素
` 例子` = [ 2 *x for x in range( 4 ) ]
print( list1)
结果:[ 0 , 2 , 4 , 6 ]
names = [ '****' ,'lwx' ,'xhs' ,'alice' ,'tony' ]
name = [ name.upper( ) for name in names if len( name) > 3 ]
print( name)
计算 30 以内可以被 3 整除的整数：
multiples = [ i for i in range( 30 ) if i % 2 != 0 ]
print( multiples)
结果:[ 1 , 3 , 5 , 7 , 9 , 11 , 13 , 15 , 17 , 19 , 21 , 23 , 25 , 27 , 29 ]
1 .字典推导基本格式：
{ key_expr: value_expr for value in collection }
或
{ key_expr: value_expr for value in collection if condition }
` 案例1` = [ 'Google' ,'Taobao' ,'JD' ]
newdict = { key:len( key) for key in listdict if len( key) >= 2 }
print( newdict)
` 案例2` = { x:x**2 for x in ( 2,4 ,6) if x < 5 }
print( dic,type( dic))
` 案例3` = [ '****' ,'lwx' ,'xhs' ,'alice' ,'toml' ]
names = { i:i*1+'hh' for i in name if len( i) > 3 }
print( names.keys( ))
print( names.values( ))
print( names[ 'alice' ] )
结果:
dict_keys( [ 'alice' , 'toml' ] )
dict_values( [ 'alicehh' , 'tomlhh' ] )
alicehh
集合推导式基本格式：
{ expression( 表达式) for item( 项目) in Sequence( 序列) }
或
{ expression for item in Sequence if conditional }
` 案例` set = { i**2 for i in range( 1,10 ) if i < 5 }
print( set)
` 结果` { 16 , 1 , 4 , 9 } --因为条件为i< 5 则只有0-4会进行计算输出
` 案例2` = { x for x in 'abcdefghijklmn' if x not in 'abcd,hijk' }
print( a)
元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。
元组推导式基本格式：
( expression( 表达式) for item( 项目) in Sequence( 序列) )
或
( expression for item in Sequence if conditional( 条件) )
` 案例` = ( x for x in range( 1,10 ) if x >= 1 )
print( a)
print( tuple( a))
结果:
< generator object < genexpr> at 0x0000025F1BCB06D8 >( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 )
1 .ubuntu
env:PRETTY_NAME= "Ubuntu 20.04.5 LTS"
--安装依赖包
root@ubuntu:~/python
--下载对应的python包
--安装python
root@ubuntu:~/python/software
root@ubuntu:~/python/software/Python-3.11.1
root@ubuntu:~/python/software/Python-3.11.1
root@ubuntu:~
root@ubuntu:~/python/software/Python-3.11.1
root@ubuntu:~/python/software/Python-3.11.1
Python 3.11 .1 --完成
------------------------------------------------------------------------------------------------------------
2 .centos
env:CentOS Linux release 7.9 .2009 ( Core)
--安装依赖包
[ root@python ~]
--下载对应的python包
--安装python包
[ root@python python]
[ root@python Python-3.11.1]
[ root@python Python-3.11.1]
[ root@python bin]
/usr/local/python3.11/bin --进入编译后的目录
[ root@python bin]
Python 3.11 .1
[ root@python bin]
[ root@python bin]
[ root@python bin]
Python 3.11 .1 ( main, Dec 15 2022 , 05:04:41) [ GCC 4.8 .5 20150623 ( Red Hat 4.8 .5-44) ] on linux
Type "help" , "copyright" , "credits" or "license" for more information.
--修复yum
linux系统中yum程序默认使用python2版本，
[ root@python bin]
[ root@python bin]
[ root@python bin]
Python 3.11 .1 --OK
1 .用法
+ 加 - 两个对象相加 a + b 输出结果 31
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -11
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 210
/ 除 - x 除以 y b / a 输出结果 2.1
% 取模 - 返回除法的余数 b % a 输出结果 1
** 幂 - 返回x的y次幂 a**b 为10的21次方
// 取整除 - 向下取接近商的整数 >> > 9 //2 4 >> > -9//2 -5
2 .案例
a = 21
b = 10
c = 0
print( a+b+c) --31
print( a-b-c) --11
print( a*b-c) --210
print( a/b+c) --2.1
print( a%b) --1( 返回余数) --21除10结果为2( 不返回) 余数为1
a = 2
b = 3
c = a**b
print( 'c的值为:' ,c) --8( 2 的3次方)
a = 12
b = 5
c = a//b
print( 'c的值为:' ,c) --2( 取整除数字)
1 .语法
以下假设变量a为10，变量b为20:
== 等于 - 比较对象是否相等 ( a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 ( a != b) 返回 True。
> 大于 - 返回x是否大于y ( a > b) 返回 False。
< 小于 - 返回x是否小于y.所有比较运算符返回1表示真,返回0表示假.这分别与特殊的变量True和False等价.注意,这些变量名的大写
>= 大于等于 - 返回x是否大于等于y。 ( a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 ( a <= b) 返回 True。( 尽量少用,< 就会返回true)
2 .案例
a = 10
import time
b = int( input( "输入数字b:" ))
if True:
print( "开始计算" )
time.sleep( 1 )
if ( a== b) :
print( 'a == b' )
exit( 0 )
elif ( a < b) :
print( 'a < b' )
exit( 0 )
else:
print( 'a > b' ,'a != b' )
exit( 1 )
1 .以下假设变量a为10，变量b为20：
运算符 描述 实例
= 简单的赋值运算符c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a
:= 海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。
在这个示例中，赋值表达式可以避免调用 len( ) 两次:
if ( n := len( a)) > 10 :
print( f"List is too long ({n} elements, expected <= 10)" )
2 .案例
a = 2
b = 3
c = a+b
print( c) --5
c += a
print( c)
c -= a
print( c) --5
c *= a
print( c) --10
c = c / a
print( c) --5.0
c //= a
print( c) --2.0
c **= a
print( c) --4
c %= a
print( c) --0( 可以整除返回0)
1 .按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
下表中变量 a 为 60 ，b 为 13 二进制格式如下：
& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 ( a & b) 输出结果 12 ，二进制解释： 0000 1100
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 ( a | b) 输出结果 61 ，二进制解释： 0011 11001
^ 按位异或运算符：当两对应的二进位相异时，结果为1 ( a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 ( ~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由"<<" 右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
>> 右移动运算符：把">>" 左边的运算数的各二进位全部右移若干位，">>" 右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111
` 案例` = 60
b = 13
c = 0
c = a & b
print( "1 - c 的值为：" , c) --12
c = a | b
print( "2 - c 的值为：" , c) --61
c = a ^ b
print( "3 - c 的值为：" , c) --49
c = ~a
print( "4 - c 的值为：" , c) --( -61)
c = a << 2
print( "5 - c 的值为：" , c) --240
c = a >> 2
print( "6 - c 的值为：" , c) --15
1 .Python语言支持逻辑运算符，以下假设变量 a 为 10 , b为 20 :
and x and y 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 ( a and b) 返回 20 。
or x or y 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 ( a or b) 返回 10 。
not not x 布尔"非" - 如果 x 为 True，返回 False.如果x为False,它返回-True not( a and b) 返回 False
2 .` 案例` = 123
b = 345
if ( a > 10 and b > 10 ) :
print( "yes" )
else:
print( "no" )
a = 9 ; b = 10
if ( a > 10 or b == 10 ) :
print( "true" )
else:
print( "false" )
if ( a != 8 ) :
print( "true" )
else:
print( "false" )
除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
` 案例` import time
a = 10
b = 20
list = [ 1,2 ,3,4,5]
if a in list:
print( list[ a] )
else:
print( f"{a} is not in list" )
time.sleep( 0.5 )
print( 'but' )
new_list = [ 10,22 ,33,44,55,66,77,88,99]
if a not in new_list:
print( f'{a} is not in new_list' )
else:
print( f'{a} is in new_list' )
身份运算符用于比较两个对象的存储单元
运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id( x) == id( y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id( x) != id( y) 。如果引用的不是同一个对象则返回结果 True，否则返回 False。
` 案例` = 20
b = 20
if ( a is b) :
print( "a == b" )
else:
print( "a != b" )
a = "haha"
b = "nono"
if ( a is not b) :
print( "a != b" )
else:
print( "a == b" )
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
` 案例` = [ 1,2 ,3,4]
b = a
if ( a is b) : --此处判断是a是否和b都引用了同一个元素[ 1,2 ,3,4]
print( "true" ) --所以此处返回结果为true
else:
print( f"false b is{b}" )
b = a[ 0 :2] --b为0-2的列表内容
print( a[ 0 :2] )
if ( a == b) : --== 判断元素值是否相同
print( "true" )
else:
print( "false" ) --此处返回false
` 案例` = 20
b = 10
c = 5
d = 2
e = ( a + b ) * c / d
print( e) --75.0
e = a + ( b * c ) - d
print( e)
x = 'true'
y = 'false'
z = 'false'
if x or y and z:
print( "yes" )
else:
print( "false" )
运算符 描述 (expressions...),[expressions...], {key: value...}, {expressions...}圆括号的表达式 x[index], x[index:index], x(arguments...), x.attribute读取，切片，调用，属性引用 await x await 表达式 **乘方(指数) +x, -x, ~x正，负，按位非 NOT *, @, /, //, %乘，矩阵乘，除，整除，取余 +, -加和减 <<, >>移位 &按位与 AND ^按位异或 XOR ` ` in,not in, is,is not, <, <=, >, >=, !=, ==比较运算，包括成员检测和标识号检测 not x逻辑非 NOT and逻辑与 AND or逻辑或 OR if -- else条件表达式 lambdalambda 表达式 :=赋值表达式
1 .Python 支持三种不同的数值类型：
整型( int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔( bool) 是整型的子类型。
浮点型( float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250 ）
复数( ( complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex( a,b) 表示， 复数的实部a和虚部b都是浮点型。
--我们可以使用十六进制和八进制来代表整数：
number = 0xA0F
print( number) --2575
number = 0o37
print( number) --31
Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex( a,b) 表示， 复数的实部a和虚部b都是浮点型。
int float complex 10 0.0 3.14j 100 15.20 45.j -786 -21.9 9.322e-36j 080 32.3e+18 .876j -0490 -90. -.6545+0J -0x260 -32.54e100 3e+26J 0x69 70.2E-12 4.53e-7j
abs( x) 返回数字的绝对值，如abs( -10) 返回 10
ceil( x) 返回数字的上入整数，如math.ceil( 4.1 ) 返回 5
exp( x) 返回e的x次幂( ex) ,如math.exp( 1 ) 返回2.718281828459045
fabs( x) 返回数字的绝对值，如math.fabs( -10) 返回10.0
floor( x) 返回数字的下舍整数，如math.floor( 4.9 ) 返回4
log( x) 如math.log( math.e) 返回1.0,math.log( 100,10 ) 返回2.0
log10( x) 返回以10为基数的x的对数，如math.log10( 100 ) 返回2.0
max( x1, x2,.. .) 返回给定参数的最大值，参数可以为序列。 返回最大的变量值
min( x1, x2,.. .) 返回给定参数的最小值，参数可以为序列。 返回最小变量值
pow( x, y) x**y 运算后的值。
round( x) 返回浮点数 x 的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt( x) 返回数字x的平方根。
` 案例` a = 11.2
print( math.ceil( a))
choice( seq) 从序列的元素中随机挑选一个元素，比如random.choice( range( 10 )) ，从0到9中随机挑选一个整数。
randrange ( [ start,] stop [ ,step] ) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random( ) 随机生成下一个实数，它在[ 0,1 ) 范围内。
seed( [ x] ) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle( lst) 将序列的所有元素随机排序
uniform( x, y) 随机生成下一个实数，它在[ x,y] 范围内。
-----使用手册
` choice( seq) ` import random
print ( "从 range(100) 返回一个随机数 : " ,random.choice( range( 100 )) )
print ( "从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : " , random.choice( [ 1 , 2 , 3 , 5 , 9 ] ))
print ( "从字符串中 'Runoob' 返回一个随机字符 : " , random.choice( 'Runoob' ))
--结果
从 range( 100 ) 返回一个随机数 : 84
从列表中 [ 1 , 2 , 3 , 5 , 9 ] ) 返回一个随机元素 : 1
从字符串中 'Runoob' 返回一个随机字符 : u
` randrange( ) ` import random
print( "randrange(1,6,2):" ,random.randrange( 1,6 ,2)) --范围为1-6指定递增的步伐为2,及结果为1+2或者( 1 +2) +2以此类推最大为6
print ( "randrange(100) : " , random.randrange( 100 ))
--结果
randrange( 1,6 ,2) : 5
randrange( 100 ) : 10
--randrange( 0,100 , 2 )
--randrange( 0,100 , 4 )
--randrange( 1,100 , 3 )
` random` ( a,b] --半开区间包含b不包含a == a < x <= b
( a,b) --开区间不包含a和b的值 == a < x < b
[ a,b] --闭区间包含a和b的值 == a<= x <= b
--案例
import random
print ( "random() : " , random.random( )) --只能生成包含0-1内的float数字
print ( "random() : " , random.random( ))
--结果
random( ) : 0.27844640535608645
random( ) : 0.7631633645522709
` seed` import random
random.seed( 10 )
print( "种子数字为10,生成随机数: " ,random.random( )) --声明种子数字seed后,[ 0,1 ) 的随机数为一致的
random.seed( 10 )
print( "种子数字为10,生成随机数: " ,random.random( )) --声明种子数字seed后,[ 0,1 ) 的随机数为一致的
random.seed( )
print( "种子数字为空,生成随机数: " ,random.random( )) --声明随机的seed后,random不一致
--结果
种子数字为10,生成随机数: 0.5714025946899135
种子数字为10,生成随机数: 0.5714025946899135
种子数字为空,生成随机数: 0.5373277903654347
` shuffle` import random --导入随机数模块
list = [ 1,2 ,3,4] --定义列表
random.shuffle( list) --通过shuffle随机数函数将list进行处理
print( "随机列表为:" ,list) --返回处理后的数据
--结果
随机列表为: [ 2 , 3 , 1 , 4 ]
` uniform` import random
print( "uniform(5,10) 随机浮点数为:" ,random.uniform( 5,10 )) --生成5-10的随机浮点数
print( "uniform(11,20,2)随机浮点数为:" ,round( random.uniform( 11,20 ) ,2)) --生成随机浮点数精确到小数点后俩位
--结果
uniform( 5,10 ) 随机浮点数为: 6.7631951466591245
uniform( 11,20 ,2) 随机浮点数为: 15.23
Python包括以下三角函数：
函数 描述
acos( x) 返回x的反余弦弧度值。
asin( x) 返回x的反正弦弧度值。
atan( x) 返回x的反正切弧度值。
atan2( y, x) 返回给定的 X 及 Y 坐标值的反正切值。
cos( x) 返回x的弧度的余弦值。
hypot( x, y) 返回欧几里德范数 sqrt( x*x + y*y) 。
sin( x) 返回的x弧度的正弦值。
tan( x) 返回x弧度的正切值。
degrees( x) 将弧度转换为角度,如degrees( math.pi/2) ， 返回90.0
radians( x) 将角度转换为弧度
数字常量
常量 描述
pi 数学常量 pi（圆周率，一般以π来表示）
e 数学常量 e，e即自然常数（自然常数）。
转义字符 描述 实例 (在行尾时) 续行符 >>> print(“line1 \ … line2 \ … line3”) line1 line2 line3` \ 反斜杠符号 >>> print("\\")’ 单引号 >>> print('\'')" 双引号 >>> print("\"")\a 响铃 >>> print("\a")执行后电脑有响声。\b 退格(Backspace) >>> print("Hello \b World!") result:Hello World!\000 空 >>> print("\000") 输出空\n 换行 >>> print("\n")\v 纵向制表符 >>> print(“Hello \v World!”) Hello World! \t 横向制表符 >>> print("Hello \t World!")\r 回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。 >>> print(“Hello\rWorld!”) World! \f 换页 \yyy 八进制数，y 代表 0~7 的字符，例如：\012 代表换行。 \xyy 十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行 \other 其它的字符以普通格式输出
操作符 描述 实例
+ 字符串连接 a + b 输出结果： HelloPython
* 重复输出字符串 a*2 输出结果：HelloHello
[ ] 通过索引获取字符串中字符 a[ 1 ] 输出结果 e
[ : ] 截取字符串中的一部分，遵循左闭右开原则( 末位不要) ，str[ 0 :2] 是不包含第3个字符的。a[ 1 :4] 输出结果ell
in 成员运算符 - 如果字符串中包含给定的字符返回 True 'H' in a 输出结果 True --H在a( Hello) 中
not in 成员运算符 - 如果字符串中不包含给定的字符返回 True 'M' not in a 输出结果 True --M不在a( Hello) 中
r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
print( r'\n' ) print( R'\n' )
% 格式字符串
1 .在Python中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
符 号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址
` 案例` ( "我叫%s,今年%d岁!" % ( "小明" ,10))
格式化操作符辅助指令:
符号 功能
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号( + )
< sp> 在正数前面显示空格
0 显示的数字前面填充'0' 而不是默认的空格
% '%%' 输出一个单一的'%'
( var) 映射变量( 字典参数)
m.n. m 是显示的最小总宽度,n 是小数点后的位数( 如果可用的话)
Python2.6 开始，新增了一种格式化字符串的函数 str.format( ) ，它增强了字符串格式化的功能。
1 .para_str = "" "这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \ t ) 。
也可以使用换行符 [ \ n ] 。
"" "
print ( para_str)
2 .f-string
name = 'randon'
print( f'hello {name}' ) == print( 'hello %s' % name )
x = 1
print( f'{x+1=}' )
` Unicode 字符串` 1 capitalize( )
` 案例` >> hh = "this is new string study"
>> print( f"将hh中的str进行转换:{hh}" ,f"修改为:{hh.capitalize()}" )
== 将hh中的str进行转换:this is new string study 修改为:This is new string study
>> > str = "123 hello PYTHON"
>> > str.capitalize( )
'123 hello python' --str中开头第一个字符不为大写字符不会发生变化.所有字符替换为小写
需要注意的是：
@1= 首字符会转换成大写，其余字符会转换成小写。
@2= 首字符如果是非字母，首字母不会转换成大写，会转换成小写。
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+------
2 center( width, fillchar)
center( ) 方法语法：
str.center( width[ , fillchar] )
` 案例` >> > str = 'runbo' --指定字符串
>> > print( "str.center(20,'*')" ,str.center( 20 ,'*' ) ,len( str.center( 20 ,'*' )) ) --指定字符串的总长度为20字符,用*进行填充
>> > print( len( str.center( 20 ,'*' )) )
str.center( 20 ,'*' ) --**runbo--*** 20 --可以看到runbo+*一共有20个字符
--如果width( 宽度) 小于字符串宽度直接返回字符串，不会截断:
@1= print( '123' .center( 4 , '*' ))
@2= print( '1234' .center( 5 , '*' ))
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+------
3 count( str, beg = 0 ,end= len( string))
count( ) 方法语法：
str.count( sub, start = 0 ,end= len( string))
` 参数` 0 。默认为字符串的最后一个位置。
` 案例` >> > str = 'www.coo123.com'
>> > sub = "o" --定义要查询的字符
>> > print( "str.count('o')" ,str.count( f"{sub}" ,0,-1)) --查询str中o出现的次数,索引为全部字符
str.count( 'o' ) 3 --全文字符中出现了3次
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
4 bytes.decode( encoding= "utf-8" , errors = "strict" ) {
语法
decode( ) 方法语法：
bytes.decode( encoding= "utf-8" , errors = "strict" )
参数
encoding -- 要使用的编码，如"UTF-8" 。
errors -- 设置不同错误的处理方案。默认为 'strict' ,意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore' , 'replace' , 'xmlcharrefreplace' , 'backslashreplace' 以及通过 codecs.register_error( ) 注册的任何值。
}
` 案例` >> str = '学习之路'
>> str_utf8 = str.encode( "utf-8" ) --给str进行编码,类型为utf-8
>> del str --删除str的定义
>> str = '我爱python' --重新定义str的内容
>> str_gbk = str.encode( "GBK" ) --给str进行编码,类型为GBK
>> print( "UTF-8编码:" ,str_utf8) ; print( "GBK编码" ,str_gbk) --打印出utf-8编码后的内容以及GBK的编码内容
>> print( "utf-8解码:" ,str_utf8.decode( 'utf-8' ,'strict' )) --打印出解码的内容
>> print( "GBK解码:" ,str_gbk.decode( 'GBK' ,'strict' ))
UTF-8编码: b'\xe5\xad\xa6\xe4\xb9\xa0\xe4\xb9\x8b\xe8\xb7\xaf'
GBK编码 b'\xce\xd2\xb0\xaepython'
utf-8解码: 学习之路
GBK解码: 我爱python
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
5 encode( encoding= 'UTF-8' ,errors= 'strict' )
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
6 endswith( suffix, beg = 0 , end = len( string))
endswith( ) 方法语法：
str.endswith( suffix[ , start[ , end] ] )
参数
suffix -- 该参数可以是一个字符串或者是一个元素。
start -- 字符串中的开始位置。
end -- 字符中结束位置。
` 案例` >> str = '**** is good boy!!!'
>> print( str.endswith( '!' ,0,-1)) --查看str中0--1的索引内容及全部内容是否以! 进行结尾.会遵循左闭右开原则
>> del str
>> str = '**** is not good boy@@'
>> suffix = '@'
>> print( str.endswith( suffix,0,-4)) --查看str中0--4索引内容是否结尾为@,明显结果为false
--结果
True
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
7 expandtabs( tabsize= 8 )
expandtabs( ) 方法语法：
str.expandtabs( tabsize= 8 )
参数
tabsize -- 指定转换字符串中的 tab 符号 \ t 转为空格的字符数.
` 案例` >> str = 'runnbo\t12345\t123'
>> print( str)
>> print( str.expandtabs( ))
>> print( str.expandtabs( 10 ) ,len( str.expandtabs( 10 )) )
--结果
runnbo 12345 123
runnbo 12345 123
runnbo 12345 123 23
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
8 find( str, beg = 0 , end = len( string))
find( ) 方法语法：
str.find( str, beg = 0 , end = len( string))
参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
` 案例` >> info = 'abcda'
>> print( info.find( 'a' ,1)) --查询字符串中是否包含a,从下标1开始及索引1开始.
>> print( info.find( 'e' ) ,info.find( 'c' )) --查询是否包含e,和c
--结果
4 --索引4时发现a
-1 2 ---1为未发现,索引2发现c
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
9 index( str, beg = 0 , end = len( string))
index( ) 方法语法：
str.index( str, beg = 0 , end = len( string))
参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
` 案例` >> info = 'this is find index usege'
>> str1 = 'index'
>> print( info.index( str1))
>> print( info.index( 'useage' ,0,-1))
--结果
13
ValueError: substring not found --没有会报错误
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
10 isalnum( )
isalnum( ) 方法语法：
str.isalnum( )
` 案例` >> info = 'this is find index usege'
>> print( info.isalnum( )) --字符串中有特殊符号则为false
>> del info
>> info = 'asdsda123' --字符串中没有特殊符号则为true
>> print( info.isalnum( ))
--结果
False
True
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
11 isalpha( )
isalpha( ) 方法语法：
str.isalpha( )
` 案例` >> str = 'rundo'
>> print( str.isalpha( ))
>> del str
>> str = '123haha..'
>> print( str.isalpha( ))
--结果
True --必须变量内容中只包含字符串才会返回true
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
12 isdigit( )
` 案例` >> num1 = '123'
>> print( num1.isdigit( ))
>> num2 = 'ashdhasd'
>> print( num2.isdigit( ))
--结果
True
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
13 islower( )
` 案例` >> str1 = 'HH123hh'
>> print( str1.islower( ))
>> str2 = 'hhsadhh123'
>> print( str2.islower( ))
--结果
False
True
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
14 isnumeric( )
` 案例` >> num1 = '123456'
>> print( num1.isnumeric( ))
>> num2 = 'hh123'
>> print( num2.isnumeric( ))
--结果
True
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
15 isspace( )
` 案例` >> str1 = ' '
>> print( str1.isspace( ))
>> str1 = '123hh..'
>> print( str1.isspace( ))
--结果
True --变量内容只有空格的时候才会是true
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
16 istitle( )
` 案例` >> str1 = 'This Is Ha 123..##'
>> print( str1.istitle( ))
>> str1 = 'this is h '
>> print( str1.istitle( ))
--结果
True --字符串中单个单词的开头必须为大写才会返回true
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
17 isupper( )
` 案例` >> str1 = 'HELLOWORD%^&*I123213..'
>> print( str1.isupper( ))
>> str1 = 'this is h '
>> print( str1.isupper( ))
--结果
True
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
18 join( seq)
>> s1 = ""
>> s2 = ".."
>> str_list = ( '1' ,'n' ,'s' ,'3' )
>> print( s1.join( str_list))
>> print( s2.join( str_list))
--结果
1ns3
1 .. n.. s.. 3
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
19 len( string)
` 案例` >> s1 = 'hahhaha'
>> print( len( s1) ,s1)
--结果
7
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
20 ljust( width[ , fillchar] )
ljust( ) 方法语法：
str.ljust( width[ , fillchar] )
参数：
width -- 指定字符串长度。
fillchar -- 填充字符，默认为空格。
` 案例` >> str = 'love is fuck moving'
>> print( str.ljust( 25 ,'*' )) --25为字符总长,不足的用*号代替.类似center
--结果
love is fuck moving--*
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
21 lower( )
` 案例` >> str = 'love is FUck MOVING'
>> print( str.lower( ))
--结果
love is fuck moving
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
22 lstrip( )
` 案例` >> str = '##### love is FUck MOVING'
>> newstr = ( str.lstrip( '#' )) --删除左边字符包含
>> print( newstr.lstrip( )) --删除左侧包含空格的内容
--结果
love is FUck MOVING
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
23 maketrans( )
maketrans( ) 方法语法：
string.maketrans( x[ , y[ , z] ] )
参数
x -- 必需，字符串中要替代的字符组成的字符串。
y -- 可选，相应的映射字符的字符串。
z -- 可选，要删除的字符。
` 案例` >> txt = "Google Runoob Taobao!"
>> x = "Glgu" --要替换的内容
>> y = "1234" --替换后的内容
>> z = "o!"
>> mytable = txt.maketrans( x, y, z) --设定要映射的表格
>> print( txt.translate( mytable)) --translate根据给出的表格进行字符串的转换
--结果
132e R4nb Taba
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
24 max( str)
` 案例` >> str = 'abcdzx'
>> print( max( str) ,min( str))
--结果
z a
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
25 min( str)
` 案例` >> str = 'abcdzx'
>> print( max( str) ,min( str))
--结果
z a
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
26 replace( translateold, new [ , max] )
` 案例` >> str = 'www.qqkj.com'
>> print( "强强科技新地址:" ,str.replace( "qqkj" ,"gok" ))
>> new_str = 'www.www.www.www'
>> print( new_str.replace( "www" ,"hh" ,3)) --替换字符中的www为hh最多替换三次
--结果
强强科技新地址: www.gok.com
hh.hh.hh.www
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
27 rfind( str, beg = 0 ,end= len( string))
` 案例` >> str = 'www.qqkj.com'
>> print( str.rfind( 'm' ))
--结果
11 --11的索引位为m,没找到是notfound
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
28 rindex( str, beg = 0 , end = len( string))
` 案例` >> str = 'www.qqkj.com'
>> print( str.rindex( 'm' ) ,str.rfind( 'hhh' ))
--结果
11 -1 --( -1) 为未找到,字符串中不包含hhh
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
29 rjust( width,[ , fillchar] )
` 案例` >> str = ' www.qqkj.com'
>> print( str.rjust( 15 ,'*' ))
--结果
** www.qqkj.com --从右往左数15个字符不够则用*代替
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
30 rstrip( )
` 案例` >> str = ' www.qqkj.com**'
>> print( str.rstrip( "**" ) +str.strip( ))
--结果
www.qqkj.comwww.qqkj.com** --右对齐删除**,左对齐删除空格
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
31 split( str= "" , num = string.count( str))
split( ) 方法语法：
str.split( str= "" , num = string.count( str))
参数
str -- 分隔符，默认为所有的空字符，包括空格、换行( \ n) 、制表符( \ t) 等。
num -- 分割次数。默认为 -1, 即分隔所有。
` 案例` >> url = "http://www.baidu.com/python/image/123456.jpg"
>> print( url.split( "/" )) ; print( url.split( "/" ) [ -1] ) --输出以/号分隔的内容,不指定次数,遇到就分隔.输出-1索引值
>> print( url.split( "/" ,2)) --以/进行分隔,分隔俩次
--结果
[ 'http:' , '' , 'www.baidu.com' , 'python' , 'image' , '123456.jpg' ]
123456 .jpg
[ 'http:' , '' , 'www.baidu.com/python/image/123456.jpg' ]
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
32 splitlines( [ keepends] )
splitlines( ) 方法语法：
str.splitlines( [ keepends] )
` 案例` >> str = '1234\n12321\n123\r'
>> print( str.splitlines( )) --默认false,输出不带换行符,以换行符进行分隔
>> print( str.splitlines( True)) --true输出后的内容携带换行符
--结果
[ '1234' , '12321' , '123' ]
[ '1234\n' , '12321\n' , '123\r' ]
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
33 startswith( substr, beg = 0 ,end= len( string))
` 案例` >> str = 'www.baidu.com'
>> print( str.startswith( 'www' ,0,3))
>> del str
>> str = 'jd.123.com'
>> print( str.startswith( 'jde' ,0,3))
--结果
True
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
34 strip( [ chars] )
Python strip( ) 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。
注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
` 案例` >> str = "****www.baidu.com--&&-***"
>> print( str.strip( "*" ))
--结果
www.baidu.com--&& - --只删除开头和结尾是*的内容
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
35 swapcase( )
` 案例` >> str = "WWW.BAIdu.com"
>> print( str.swapcase( ))
--结果
www.baiDU.COM
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
36 title( )
` 案例` >> str = "www.baidu.com"
>> print( str.title( ))
>> str = '123w,1w2w3w,4c5d'
>> print( str.title( ))
--结果
Www.Baidu.Com
123W,1W2W3W,4C5D --非字母后的第一个字母会被转换为大写
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
37 translate( table, deletechars = "" )
语法
translate( ) 方法语法：
str.translate( table)
bytes.translate( table[ , delete] )
bytearray.translate( table[ , delete] )
参数
table -- 翻译表，翻译表是通过 maketrans( ) 方法转换而来。
deletechars -- 字符串中要过滤的字符列表。
` 案例` >> intab = "aeiou"
>> outtab = "12345"
>> trantab = str.maketrans( intab, outtab)
>> str = "this is string example....wow!!!"
>> print ( str.translate( trantab))
--结果
th3s 3s str3ng 2x1mpl2.. .. w4w! ! !
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
38 upper( )
` 案例` >> table = 'asdas1312,888'
>> print( table.upper( ))
--结果
ASDAS1312,888
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
39 zfill ( width)
` 案例` = 'www.baidu.com '
print( str.zfill( 17 ))
--结果
00www.baidu.com --返回17个字符的内容,不够补0
40 isdecimal( )
` 案例` >> str = 'www.baidu.com '
>> print( str.zfill( 17 ))
>> str = '678'
>> print( str.isdecimal( ))
--结果
00www.baidu.com
True
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
1 .序列是 Python 中最基本的数据结构。
序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0 ，第二个索引是 1 ，依此类推。
Python 有 6 个序列的内置类型，但最常见的是列表和元组。
` 案例` = [ 1,2 ,3,4,5,6]
print( list[ 0 :4] )
` 结果` [ 1 , 2 , 3 , 4 ] --遵循左闭右开原则不包含4--[ )
索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。
` 案例` = [ 'google' ,'baidu' ,'yamzon' ,'taobao' ]
print( '列表的第三个元素为:' ,list[ 2 ] )
list[ 2 ] = '4399.com'
print( '更新后的第三个元素为:' ,list[ 2 ] )
print( list)
list.append( 'haha.com' )
print( '追加一个新元素后的内容为:' ,list)
` 结果` 4399 .com
[ 'google' , 'baidu' , '4399.com' , 'taobao' ]
追加一个新元素后的内容为: [ 'google' , 'baidu' , '4399.com' , 'taobao' , 'haha.com' ]
` 案例` = [ 'google' ,'baidu' ,'yamzon' ,'taobao' ]
print( '删除前的列表为:' ,list)
del list[ 3 ]
print( '删除后的列表为:' ,list)
` 结果` [ 'google' , 'baidu' , 'yamzon' , 'taobao' ]
删除后的列表为: [ 'google' , 'baidu' , 'yamzon' ]
Python 表达式 结果 描述 len([1, 2, 3]) 3 长度 [1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合 [‘Hi!’] * 4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] 重复 3 in [1, 2, 3] True 元素是否存在于列表中 for x in [1, 2, 3]: print(x, end=" ") 1 2 3 迭代
list = [ 'google' ,'baidu' ,'yamzon' ,'taobao' ]
print( len( list)) --打印出列表的长度,一个元素为一个字符
print( list[ 1 ] *4) --打印出列表的索引为1的元素,重复4次
if 'baidu' in list: --如果baidu在列表中打印true
print( "true" )
for i in list[ 0 :3] : --遍历list的0-3的元素,给i赋值并输出i,不换行
print( i,end= "" )
` 结果` 4
baidubaidubaidubaidu
true
googlebaiduyamzon
L = [ 'Google' , 'Runoob' , 'Taobao' ]
Python 表达式 结果 描述
L[ 2 ] 'Taobao' 读取第三个元素
L[ -2] 'Runoob' 从右侧开始读取倒数第二个元素: count from the right
L[ 1 :] [ 'Runoob' , 'Taobao' ] 输出从第二个元素开始后的所有元素
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
列表拼接
list = [ 1,2 ,3,4,5]
list += [ 6,7 ,8,9,10]
print( list)
` 结果` [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]
list1 = [ 'a' ,'b' ,'c' ]
list2 = [ 1,2 ,3]
new_list = [ list1,list2]
print( new_list)
print( new_list[ 0 ] [ 1 ] ) --输出列表0中的1元素
` 结果` [ [ 'a' , 'b' , 'c' ] , [ 1 , 2 , 3 ] ]
b
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
列表比较需要引入 operator 模块的 eq 方法： --eq与shell--eq一致等于
` 案例` import operator
a = [ 1,2 ]
b = [ 2,3 ]
c = [ 2,3 ]
print( "a是否等于b:" ,operator.eq( a,b))
print( 'c是否等于b:' ,operator.eq( c,b))
` 结果`
operator.lt( a, b) --less than:小于
operator.le( a, b) --less equal:小于等于
operator.eq( a, b) --equal ==
operator.ne( a, b) --!=
operator.ge( a, b) --greater equal:大于等于
operator.gt( a, b) --greater than:大于
operator.__lt__( a, b)
operator.__le__( a, b)
operator.__eq__( a, b)
operator.__ne__( a, b)
operator.__ge__( a, b)
operator.__gt__( a, b)
运算符函数
operator 模块提供了一套与 Python 的内置运算符对应的高效率函数。例如，operator.add( x, y) 与表达式 x+y 相同。
` 案例` import operator
a = 3
b = 4
print( "add()运算结果:" ,end= "" ) --end= "" :不换行输出,及下面行的打印会和此行合并
print( operator.add( a,b))
print( "sub相减:" ,end= "" )
print( operator.__sub__( a,b))
print( "mul相乘" ,end= "" )
print( operator.__mul__( a,b))
` 结果` ( ) 运算结果:7
sub相减:-1
mul相乘:12
1 .line( list)
` 案例` = [ 'Google' , 'Runoob' , 'Taobao' ]
print ( len( list1))
if 'list' in locals( ) .keys( ) :
del ( list)
list2 = list( range( 5 ))
print( len( list2) ,list2)
` 结果` 3
5 [ 0 , 1 , 2 , 3 , 4 ]
2 .max( list)
` 案例` = [ 'Google' , 'Runoob' , 'Taobao' ]
print( max( list1[ 0 :2] )) --打印出0-2元素中的最大值,根据索引进行比较
list1 = [ 1,2 ,3,7,5]
print( max( list1))
` 结果` 7 --整数型的列表按照内容数值进行比较
3 .min( list)
` 案例` = [ 1,2 ,3,7,5] ,[ 'Google' ,'baidu' ,'str' ]
print( min( list1) ,min( list2))
print( id( list2[ 0 ] ) ,id( list2[ 1 ] ) ,id( list2[ 2 ] ))
if id( list2[ 0 ] ) > id( list2[ 1 ] ) :
print( "true" )
` 结果` 1 Google
1442604729320 1442604728760 1442599766704
true
4 .list( seq)
` 案例` = ( 123 ,'google' ,213,'baidu' )
list1 = list( tuple)
print( '元组列表转换为:' ,list1[ 0 :2] )
str1 = 'Hello World'
new_list = list( str1)
print( "新的列表内容为:" ,new_list)
` 结果` [ 123 , 'google' ]
新的列表内容为: [ 'H' , 'e' , 'l' , 'l' , 'o' , ' ' , 'W' , 'o' , 'r' , 'l' , 'd' ] --字符串连同空格会被拆解
1 .list.append( obj)
` 案例` = [ 'Google' ,'Runnbo' ,'Taobao' ]
list1.append( 'baidu' )
print( list1)
` 结果` [ 'Google' , 'Runnbo' , 'Taobao' , 'baidu' ]
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
2 .list.count( obj)
` 案例` = [ 123 ,'Google' ,'Runnbo' ,123]
a = 123
print( "123在列表中出现的次数为:" ,alist.count( a))
print( 'Gooogle元素出现的次数为:' ,alist.count( 'Google' ))
` 结果` 123 在列表中出现的次数为: 2
Gooogle元素出现的次数为: 1
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
3 .list.extend( seq)
` 案例` = [ 123 ,'Google' ,'Runnbo' ,123]
alist_2 = list( range( 5 ))
alist.extend( alist_2)
print( "新的列表内容为:" ,alist)
` 结果` [ 123 , 'Google' , 'Runnbo' , 123 , 0 , 1 , 2 , 3 , 4 ]
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
4 .list.index( obj)
语法
index( ) 方法语法：
list.index( x[ , start[ , end] ] )
参数
x-- 查找的对象。
start-- 可选，查找的起始位置。
end-- 可选，查找的结束位置。
` 案例` = [ 'Google' ,'baidu' ,'alibaba' ]
print( 'Google的索引位置为:' ,list1.index( 'Google' ))
print( 'alibaba的索引位置为' ,list1.index( 'alibaba' ,1-2)) --从1的索引位置开始
` 结果` 0
alibaba的索引位置为 2
5 .list.insert( index, obj)
参数
index -- 对象obj需要插入的索引位置。
obj -- 要插入列表中的对象。
` 案例` = [ 'Google' ,'baidu' ,'alibaba' ]
list1.insert( 1 ,'jingdong' )
print( "在元素1后插入新的元素:" ,list1)
` 结果` [ 'Google' , 'jingdong' , 'baidu' , 'alibaba' ]
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
6 .list.pop( [ index= -1] )
` 案例` = [ 'Google' ,'baidu' ,'alibaba' ]
list1.insert( 1 ,'jingdong' )
list1.pop( )
print( '取出索引最后位的值抛弃后的列表为:' ,list1)
list1.pop( 0 )
print( "取出第一位:" ,list1)
` 结果` [ 'Google' , 'jingdong' , 'baidu' ]
取出第一位: [ 'jingdong' , 'baidu' ]
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
7 .list.remove( obj)
` 案例` = [ 'Google' ,'baidu' ,'alibaba' ]
list1.remove( 'Google' )
print( "移除列表中的Google" ,list1)
` 结果` [ 'baidu' , 'alibaba' ]
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
8 .list.reverse( )
` 案例` = [ 'Google' ,'baidu' ,'alibaba' ]
list1.reverse( )
print( '列表元素反转:' ,list1)
` 结果` [ 'alibaba' , 'baidu' , 'Google' ]
9 .list.sort( key = None, reverse = False)
参数
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
` 案例` = [ 'a' ,'e' ,'i' ,'b' ,'d' ]
list1.sort( reverse= True) --使用降序排序
print( list1)
` 结果` [ 'i' , 'e' , 'd' , 'b' , 'a' ]
` 案例2` ( elem) : --定义函数体,只有调用的时候才会生效
return elem[ 1 ] --返回elem中的元素1
random = [ ( 2 , 2 ) , ( 3 , 4 ) , ( 4 , 1 ) , ( 1 , 3 ) ]
random.sort( key= takeSecond) --以元素1进行排序
print( '排序列表:' ,random)
` 结果` [ ( 4 , 1 ) , ( 2 , 2 ) , ( 1 , 3 ) , ( 3 , 4 ) ]
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
10 . list.clear( )
list1 = [ 'Google' ,'baidu' ,'jingdong' ,'alibaba' ]
list1.clear( )
print( list1)
` 结果` [ ]
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
11 .list.copy( )
` 案例` = [ 'Google' ,'baidu' ,'jingdong' ,'alibaba' ]
list2 = list1.copy( )
print( list2)
` 结果` [ 'Google' , 'baidu' , 'jingdong' , 'alibaba' ]
1 .Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( ) ，列表使用方括号 [ ] 。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
--定义元组
>> > tup1 = ( 'Google' , 'Runoob' , 1997 , 2000 )
>> > tup2 = ( 1 , 2 , 3 , 4 , 5 )
>> > tup3 = "a" , "b" , "c" , "d"
>> > tup4 = ( )
元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：
>> > tup1 = ( 50 )
>> > type( tup1)
< class 'int' >
>> > tup1 = ( 50 ,)
>> > type( tup1)
< class 'tuple' >
` 案例` = ( 'Google' ,'Runnbo' ,1997,2000)
tup2 = ( 1,2 ,3,4,5,6,7)
print( "tup1[0]:" ,tup1[ 0 ] )
print( "tup2[1]:" ,tup2[ 1 ] )
` 结果` [ 0 ] : Google
tup2[ 1 ] : 2
` 案例` = ( 'Google' ,'Runnbo' ,1997,2000)
tup2 = ( 1,2 ,3,4,5,6,7)
tup3 = tup1 + tup2
print( tup3,tup3[ 4 ] )
` 结果` ( 'Google' , 'Runnbo' , 1997 , 2000 , 1 , 2 , 3 , 4 , 5 , 6 , 7 ) 1
删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
` 案例` = ( 'Google' ,'Runnbo' ,1997,2000)
print( tup1)
del tup1
print( "删除后的元组:" ,tup1)
print( tup1)
` 结果` ( 'Google' , 'Runnbo' , 1997 , 2000 )
NameError: name 'tup1' is not defined
与字符串一样，元组之间可以使用 +、+= 和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
Python 表达式 结果 描述 len((1, 2, 3))3 计算元素个数 >>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> c = a+b >>> c (1, 2, 3, 4, 5, 6)(1, 2, 3, 4, 5, 6) 连接，c 就是一个新的元组，它包含了 a 和 b 中的所有元素。 >>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> a += b >>> a (1, 2, 3, 4, 5, 6)(1, 2, 3, 4, 5, 6) 连接，a 就变成了一个新的元组，它包含了 a 和 b 中的所有元素。 ('Hi!',) * 4(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’) 复制 3 in (1, 2, 3)True 元素是否存在 for x in (1, 2, 3): print (x, end=" ")1 2 3 迭代
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
` 案例` = ( 'Google' , 'Runoob' , 'Taobao' , 'Wiki' , 'Weibo' ,'Weixin' )
print( tup[ 0 :-3] )
print( tup[ 0 :] )
print( tup[ -5:] )
` 结果` ( 'Google' , 'Runoob' , 'Taobao' )
( 'Google' , 'Runoob' , 'Taobao' , 'Wiki' , 'Weibo' , 'Weixin' )
( 'Runoob' , 'Taobao' , 'Wiki' , 'Weibo' , 'Weixin' )
序号 方法及描述 实例 1 len(tuple) 计算元组元素个数。 >>> tuple1 = ('Google', 'Runoob', 'Taobao') >>> len(tuple1) 3 >>> 2 max(tuple) 返回元组中元素最大值。 >>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8' >>> 3 min(tuple) 返回元组中元素最小值。 >>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4' >>> 4 tuple(iterable) 将可迭代系列转换为元组。 >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu')
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key = > value 对用冒号 : 分割，每个对之间用逗号( ,) 分割，整个字典包括在花括号 { } 中 ,格式如下所示：
emptyDict = { }
print( emptyDict)
print( "Length:" , len( emptyDict))
print( type( emptyDict))
结果:
{ }
Length: 0
< class 'dict' >
tinydict = { 'Name' : 'Runoob' , 'Age' : 7 , 'Class' : 'First' }
print( "tinydict:name=" ,tinydict[ 'Name' ] )
print( "tinydict:age=" ,tinydict[ 'Age' ] )
tinydict:name= Runoob
tinydict:age= 7
tinydict = { 'Name' : 'Runoob' , 'Age' : 7 , 'Class' : 'First' }
tinydict[ 'Age' ] = 8
tinydict[ 'school' ] = '清华大学'
print( "age=" ,tinydict[ 'Age' ] )
print( "school=" ,tinydict[ 'school' ] )
print( len( tinydict) ,tinydict.keys( ))
tinydict = { 'Name' : 'Runoob' , 'Age' : 7 , 'Class' : 'First' }
tinydict[ 'Age' ] = 20
tinydict[ 'school' ] = '清华大学'
del tinydict[ 'Age' ]
tinydict.clear( )
print( len( tinydict) ,tinydict.values( ))
print( tinydict[ 'Name' ] )
1 .Python 字典 copy( ) 函数返回一个字典的浅复制。
语法
copy( ) 方法语法：
dict.copy( )
dict1 = { 'Name' : 'Runbbo' ,'Age' : '18' ,'Class' : 'First' }
dict2 = dict1
dict3 = dict1.copy( )
dict1[ 'Name' ] = '****'
print( dict1)
print( dict2)
print( dict3)
{ 'Name' : '****' , 'Age' : '18' , 'Class' : 'First' }
{ 'Name' : '****' , 'Age' : '18' , 'Class' : 'First' }
{ 'Name' : 'Runbbo' , 'Age' : '18' , 'Class' : 'First' }
2 .Python 字典 fromkeys( ) 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
语法
fromkeys( ) 方法语法：
dict.fromkeys( seq[ , value] )
seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）对应的值，默认为 None。
seq = ( 'name' ,'age' ,'class' )
dict1 = dict.fromkeys( seq)
print( "产生的字典为:%s" % str( dict1))
dict2 = dict.fromkeys( seq,10)
print( "产生的字典为:" ,dict2)
产生的字典为:{ 'name' : None, 'age' : None, 'class' : None}
产生的字典为: { 'name' : 10 , 'age' : 10 , 'class' : 10 }
3 .Python 字典 get( ) 函数返回指定键的值。
key -- 字典中要查找的键。
value -- 可选，如果指定键的值不存在时，返回该默认值。
tinydict = { 'Name' : 'Runoob' , 'Age' : 27 }
print( tinydict.get( 'Name' ) ,tinydict.get( 'Age' ))
print( tinydict.get( 'hahah' ,123))
Runoob 27
123
4 .Python 字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。
而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true
thisdict = { 'Name' : 'Runoob' , 'Age' : 7 }
key = "Age"
if key in thisdict:
print( f'键{key}存在' )
else:
print( f'键{key}不存在' )
键Age存在
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
