python笔记之基本数据类型

python基本数据类型

运算符

算数运算符

a,b = (10,20)

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	>>> 9//2 4 >>> -9//2 -5

比较运算符

a,b = (10,20)

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等。python3 已废弃。	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

赋值运算符

以下假设变量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

逻辑运算符

a,b = (10,20)

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

示例

#and or not
# 优先级，()> not > and > or
print(2 > 1 and 1 < 4)
print(2 > 1 and 1 < 4 or 2 < 3 and 9 > 6 or 2 < 4 and 3 < 2)
# T or T or F
#T or F
print(3>4 or 4<3 and 1==1)  # F
print(1 < 2 and 3 < 4 or 1>2)  # T
print(2 > 1 and 3 < 4 or 4 > 5 and 2 < 1)  # T
print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8)  # F
print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)  # F
print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # F

# ps  int  ----> bool   非零转换成bool True   0 转换成bool 是False
print(bool(2))
print(bool(-2))
print(bool(0))
#bool --->int
print(int(True))   # 1
print(int(False))  # 0

成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

字符串

字符串常用功能：移除空白 分割 长度 索引 切片

 字符串切片

正向索引：0到长度 -1 0 1 2 3 ，负向索引：-1到负长度 -4 -3 -2 -1

a[start:end:step]

例子

s1 = 'hello world'
print(s1[0:8])
#结果是 hello wo
print(s1[0:8:2])
#结果是 hlow

字符串常用方法

len

len方法，计算字符串当的长度

s1 = "abc"
len(s1)
#结果是 3

find

find方法，在字符串中查找子串，如果可以找到，就返回子串的第一个字符的索引，否则就返回-1

s1 = 'hello world'
s1.find('e')
# 结果是1 
s1.find('x')
# 结果是 -1 

index

count方法，在字符串中查找指定元素是否存在，存在就返回index

s1 = 'hello world'
print(s1.index('h'))
#结果是 0 

count

count方法，查找指定的元素在列表中出现了多少次

s1 = 'hello world'
print(s1.count('l')) 
#结果是 3

join

join方法，是一个非常重要的字符串方法，用于合并序列的元素

l1 = ['hello', 'world']
s1 = " ".join(l1)
print(s1)
#结果是 hello world

replace

replace方法，将指定的子串都替换为另一个字符串，并返回替换后的结果

s1 = 'hello world'
print(s1.replace('h','HJ')  )
#结果是 HJello world

strip

strip方法，将字符串开头和末尾的空白(但不包括中间的空白)删除，将返回删除的结果

s1 = '  hello world '
print(s1.strip())
#结果是 'hello world'
s2= '*190  190  190*'
print(s2.strip('*'))
#结果是 '190  190  190'

split

split方法，是一个非常重要的字符串方法，其作用余join相反，用于将字符串拆分为序列

s1 = 'wuhan zhangcheng beijin'
print(s1.split()  )
#结果是 ['wuhan', 'zhangcheng', 'beijin']  //全分割
print(s1.split(maxsplit=1))  #maxsplit:最多分隔几次,
#结果是 ['wuhan', 'zhangcheng beijin']
print(s1.split()[2] )
#结果是 'beijin'
s2 = 'wuhan zhangcheng.zc'        #以逗号为分隔符,
print(s2.split('.',maxsplit=1))
#结果是 ['wuhan zhangcheng', 'zc']

center

center方法，通过在两边填充字符(默认为空格)，让字符串居中

print('zc'.center(10,'*'))     #10是总长度，*是填充符
#结果是 '****zc****'
print('zc'.center(3,'*')   )
#结果是 '*zc'
print('zc'.center(4,'*') )
#结果是 '*zc*' 

just

使用ljust及rjust函数扩充字符串位数，不足用特殊字符填充

print('zc'.ljust(4,'*'))
#结果是'zc**'
print('zc'.rjust(4,'*'))
#结果是'**zc'

upper

uppper方法，将字符串转换为大写输出

s1 = 'zxxc'
print(s1.upper())
#结果是 'ZXXC'

lower

lower方法，将字符串转为小写输出

s1 = "ASD"
print(s1.lower())
#结果是 'asd'

title

title方法，将字符串每个单词首字母大写

s1 = 'my name is zhangcheng'
print(s1.title() )
#结果是 'My Name Is Zhangcheng'

capitalize

capitalize方法，只对一个首字母大写

str = 'my name is zhangcheng'
print(str.capitalize())
#结果是 'My name is zhangcheng'

startswitch

startswitch方法，以什么为开头

print("hello".startswith("h"))
#结果是 True
print("hello".startswith("e"))
#结果是 False

endswitch

endswitch方法，以什么为结尾

print("hello".endswith("o"))
#结果是 True
print("hello".endswith("h") )
#结果是 False

max

max方法，返回最大的字符

print(max('aAcC') )
#结果是 c

min

min方法，返回最小的字符串

print(min('aACc'))
#结果是 A

判定字符串格式

# isupper()  有字母且均为大写则为True
print("AAAAAA".isupper())
#结果是True
print("AAAAAb".isupper())
#结果是False

# islower()  有字母且均为小写则为True
print("aaaa".islower()) 
#结果是True
print("aaaaZ".islower())
#结果是False

# istitle() 从左到右所有单词首字母大写 则为True
print("I Have A Book!".istitle())
#结果是True
print("I Have a Book!".istitle())
#结果是False

字符串格式化

Python的字符串格式化有两种方式: 百分号方式、format方式 百分号的方式相对来说比较老，而format方式则是比较先进的方式，企图替换古老的方式，目前两者并存

百分号方式 %s %d %f

%s 字符串的格式化
%d 数字的格式化
%f  浮点数的格式化
>>print("name %s,%s" %('zx','xx'))
'name zx,xx'
>>print("age%d" %(18))
'age18'
>>print("浮点数%7.2f" %(12.36))  # 7是长度，2是小数后几位
'浮点数  12.36'
>>print("浮点数%*.*f"%(20,4,12.23)) #20是长度，4是保留几位小数
'浮点数             12.2300'
>>print("浮点数%-*.*f"%(20,4,12.23))    #-号是左对齐
'浮点数12.2300
>>print("浮点数%0*.*f"%(20,4,12.23))
'浮点数000000000000012.2300'

 format方式

>>print("name:{},age:{}".format("zc","18"))
'name:zc,age:18'
>>print("name:{0},age:{1}".format("zc","18"))
'name:zc,age:18'
>>print("name:{1},age:{0}".format("zc","18"))
'name:18,age:zc'
>>print("name:{1},{0},{1},age:{0}".format("zc","18"))
'name:18,zc,18,age:zc'

列表介绍

list的表达方式: [ ],  本质上是可以改变的序列 list_name = ['a',1,2,['b',2,...]]元素之间用逗号隔开，列表之中元素类型可以不同

列表示例：

1.打印列表中的索引和元素：

for index,value in enumerate(b):
    print("index:%d,value:%s" %(index,value))

a = [1,2,1,['zc','zx',1,2],4,1,1,1,1]
for i in a:
    print(i)

2.打印某个值的index：

list_l = [1,1,2,3,4,3,2,1]
for index,value in enumerate(list_l):
    if value == 2:
        print(index)

切片

给切片赋值切片是一项极其强大的功能，而能够给切片赋值让这项功能显得更加强大

可将切片替换为长度与其相同的序列

>>x = list('perl')
>>print(x)      
>['p', 'e', 'r', 'l']
>>x[2:] = list('ra')
>>print(x) 
['p', 'e', 'r', 'a']

 可将切片替换为长度与其不同的序列

>>x = list('perl')
>>print(x)    
['p', 'e', 'r', 'l']
>>x[2:] = list('hello')
>>print(x)    
['p', 'e', 'h', 'e', 'l', 'l', 'o']

替换

在不替换原有元素的情况下插入新元素，“替换”了一个空切片，相当于插入了一个序列

x = ['1', '2', '3']
x[11100:1] = [6,7,8]
print(x)
#结果是 ['1', '2', '3', 6, 7, 8]

可采取相反的措施来删除切片

x = ['1','2', '3', 6, 7, 8 ]
x[1:5] = []
print(x)
#结果是 ['1', 8]

修改列表

列表赋值

x = [1, 1, 1]
x[1] = 2
print(x)
#结果是 [1, 2, 1]

嵌套列表的使用

a = [1,2,3,['a','b','c']]
print(a[3])
#结果是：['a', 'b', 'c']
print(a[3][0])
#结果是 'a'

range 迅速产生一个列表

a = list(range(10))
print(a)
#结果是 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

列表推导式

ret = [i for i in range(100)]
print(ret)
#结果是： [0,1,2,......,99]
ret2 = [i*i for i in range(10)]
print(ret2)
#结果是  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
ret3 = [chr(i) for i in range(ord('a'),ord('a')+26)]
print(ret3)
#结果是  ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

删除元素

a = [1,2,1,4,1,1,1,1]
for i in range(a.count(1)):
    a.remove(1)
print(a)
#结果是 [2,4]

 列表常用方法

append

方法append用于将一个对象附加到列表末尾。

lst = [1, 2, 3]
lst.append(4)
print(lst)  
#结果是 [1, 2, 3, 4]

a = ['1', '2', '3']
b = ['4', '5', '6']
a.append(b)
print(a)    
#结果是 ['1', '2', '3', ['4', '5', '6']]

insert

方法insert用于将一个对象插入列表。

numbers = [1, 2, 3, 5, 6, 7]
numbers.insert(3, 'four')
print(numbers)  
#结果是 [1, 2, 3, 'four', 5, 6, 7]

pop

不指定索引，就默认删除最后一个元素，指定索引的话，就删除与索引对应的元素，删除完成之后，并返回这一元素

x = [1, 2, 3]
print(x.pop())
#结果是  3
x = [1,2]
print(x.pop(0))
#结果是  1
print(x)
#结果是  [2]

remove

方法remove用于删除第一个为指定值的元素。

x = ['to', 'be', 'or', 'not', 'to', 'be']
x.remove('be')
print(x)
#结果是 ['to', 'or', 'not', 'to', 'be'] 

count

方法count计算指定的元素在列表中出现了多少次

x = ['to', 'be', 'or', 'not', 'to', 'be']
print(x.count('to'))
#结果是 2

clear

方法clear就地清空列表的内容

lst = [1, 2, 3]
lst.clear()
print(lst)
#结果是 []

del

删除元素和变量

x = [1,2,3,4,5,6,7]
del x[0]
print(x)
#结果是 [2, 3, 4, 5, 6, 7]
del x
print(x)
#结果报错，列表不存在，NameError: name 'x' is not defined

sort

方法sort用于对列表就地排序。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。

x = [4, 6, 2, 1, 7, 9]
x.sort()
print(x)
#结果是 [1, 2, 4, 6, 7, 9]

sorted

方法sorted返回一个排好序的列表，源列表不变

x = [1,3,5,23,3,4]
sorted(x) 
#结果是 [1, 3, 3, 4, 5, 23]
print(x)  
#结果是 [1, 3, 5, 23, 3, 4]，源列表不变

max和min

输出列表中最大值和最小值

x = [1, 3, 5, 23, 3, 4]
print(max(x)) 
#结果是23
print(min(x)) 
#结果是1

copy

copy方法 ,copy 复制列表。前面说过，常规复制只是将另一个名称关联到列表。

浅拷贝

a = [1, 2, 3]
b = a
b[1] = 4
print(a)
#结果是 [1, 4, 3]
print(id(a))
#结果是 10044840
print(id(b))
#结果是 10044840

深拷贝

import copy
#结果是
a = [1, 2, 3]
b = copy.deepcopy(a)#或者使用b = a.copy()
# 要让a和b指向不同的列表，就必须将b关联到a的副本
b[1] = 4
print(a)
#结果是 [1, 4, 3]
print(id(a))
#结果是 10044840
print(id(b))
#结果是 10044840

extend

方法extend让你能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提供给方法extend。换而言之，你可使用一个列表来扩展另一个列表。

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a)
#结果是 [1, 2, 3, 4, 5, 6]

index

方法index在列表中查找指定值第一次出现的索引

knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']
print(knights.index('who'))
#结果是 4

reverse

方法reverse按相反的顺序排列列表中的元素（我想你对此应该不会感到惊讶）

x = [1, 2, 3]
x.reverse()
print(x) 
#结果是 [3, 2, 1]
# 注意到reverse修改列表，但不返回任何值（与remove和sort等方法一样）

 list

list方法，将其他元素转换为列表

s = "china"
s1 = list(s)
print(s1)
#结果是 ['c', 'h', 'i', 'n', 'a']

字典

字典：是一个无序的容器，由键值对组成，不同键值对用逗号隔开，键和值用冒号隔开，键要唯一，且是可hash对象 不可变对象，int str tuple；值是list set tuple dict 可变对象

如：dict = {"name":'eric', "age":18, "fav":[ "pingpong",'footbool'] } 

访问字典的元素 :

　　1. 字典名称【”键名称“】

　　2. dict_a.get("键名称"，"默认值")

字典赋值 dict_a["xxx"]=value xx存在则覆盖，不存在则追加。

示例：

dict =   {"name":'eric', "age":18, "fav":[ "pingpong",'footbool'] }

dict["name"] = "zhangcheng"  
dict["salary"] = 10000000
print(dict)
#结果是 {'name': 'zhangcheng', 'age': 18, 'fav': ['pingpong', 'footbool'], 'salary': 10000000}

字典常用方法

get

访问字典元素,get(key,None) key -- 字典中要查找的键。 default -- 可选参数，如果指定键的值不存在时，返回该值，默认为 None。

a = {1:'zc',2:'zx'}
print(a.get(1))
#结果是 'zc'

keys

获取所有的键

a = {1:'zc',2:'zx'}
print(a.keys())
#结果是 dict_keys([1, 2])

 values

获取所有的值

a = {1:'zc',2:'zx'}
print(a.values())
#结果是 dict_values(['zc', 'zx'])

list

将字典的key转换成列表

a = {1: 'zc', 2: 'zx', 'zhangcheng': 123}
print(list(a))
#结果是 [1, 2, 'zhangcheng']

pop

将某个键值对给删除，通过键值来获取：

a = {1: 'zc', 2: 'zx', 'zhangcheng': 123}
print(a.pop(1))
#结果是 'zc'
print(a)
#结果是 {2: 'zx', 'zhangcheng': 123}

popitem

随机移除一个键值对，并以元组的形式返回

a = {2: 'zx', 'zhangcheng': 123}
print(a.popitem())
#结果是 ('zhangcheng', 123)
print(a)
#结果是 {2: 'zx'}

clear

清空一个字典

b = {'a': 1, 'b': 2, 'c': 3}
b.clear()
print(b)
#结果是 {}

del

删除一个字典

b = {"age":"18"}
del b
print(b)
#结果是
# Traceback (most recent call last):
#   File "<pyshell#77>", line 1, in <module>
#     b
# NameError: name 'b' is not defined

copy

a = {'a': 1, 'b': 2, 'c': 3}
b = a.copy()
print(b)
#结果是 {'a': 1, 'b': 2, 'c': 3}

dict.fromkeys

c = dict.fromkeys([1,2,3],'OK')
print(c)
#结果是 {1: 'OK', 2: 'OK', 3: 'OK'}

dict

print(dict([('a',1),('b',2)]))
#结果是 {'a': 1, 'b': 2} 

items

同时获取一个键值对的键和值

a = {1:3,2:4,3:5}
print(a.items())
print(list(a.items()))
#结果是 dict_items([(1, 3), (2, 4), (3, 5)])
#结果是 [(1, 3), (2, 4), (3, 5)]

zip

快速构建字典

print(zip([1,2],[2,3,4]))
#结果是 <zip object at 0x03592260>
print(list(zip([1,2],[2,3,4])))
#结果是 [(1, 2), (2, 3)]

Keys = [1,2,3,4,5,6]
Values = [3,4,5,6,7,8]
print(dict(zip(Keys,Values)))
#结果是 {1: 3, 2: 4, 3: 5, 4: 6, 5: 7, 6: 8}

集合

set 定义空集合：a=set()

{1,2,3,4}

集合中元素必须为不可变对象。 可hash对象集合元素是不重复的，唯一的。

集合常用方法

add

给集合新增元素

a = {1, 2, 36, 5564, 14}
a.add(40)
print(a)
# {1, 2, 36, 40, 14, 5564}

update

把原来集合中没有的元素重其他集合导入、更新

a = {1,2,3}
a.update({4,5,6})
print(a)
#{1, 2, 3, 4, 5, 6}

remove

删除集合中元素，如果元素不存在则报错

a = {1,2,3,4, 5, 6}
a.remove(6)
print(a)
#{1, 2, 3, 4, 5}

a = {1,2,3,4, 5, 6}
a.remove(0)
print(a)
#Traceback (most recent call last):
#   File "F:/study/python/code/demo/demo_list.py", line 10, in <module>
#     a.remove(0)
# KeyError: 0

discard

删除集合中的元素，如果元素不存在不报错

a = {1,2,3,4, 5, 6}
a.discard(6)
print(a)
#{1, 2, 3, 4, 5}
a.discard(0)
print(a)
# {1, 2, 3, 4, 5}

set

set的简易用法：删除重复的元素

lst = [1,1,2,3,2,23,45,6,6]
new_lst = list(set(lst))
print(new_lst)
# [1, 2, 3, 6, 45, 23]

集合求交集

a = {1,2,3,4}
b = {4,5,6,7}
print(a & b)
# {4}
print(a.intersection(b))
# {4}

集合求并集

a = {1,2,3,4}
b = {4,5,6,7}
print(a | b)
# {1, 2, 3, 4, 5, 6, 7}
print(a.union(b))
# {1, 2, 3, 4, 5, 6, 7}

集合求差集

a = {1,2,3,4,5,6,7}
b = {4,5,6,7}
print(a - b)
# {1, 2, 3}
print(a.difference(b))
# {1, 2, 3}

元组

元祖 只读列表，可循环查询，可切片。 儿子不能改，孙子可能可以改

>>> tu = (1,2,3,[1,2,3])
>>> tu[0] = 100
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> tu[-1][0] = 100
>>> tu
(1, 2, 3, [100, 2, 3])

元组定义

>>> t = ()
>>t
()
>>> print(type(t))
<class 'tuple'>
>>> t = tuple()
>>> t
()
>>> print(type(t))
<class 'tuple'>
>>> t = (1)  此时t是数字类型
>>> print(type(t))
<class 'int'>
>>> t = (1,)
>>> print(type(t))
<class 'tuple'>

元组常用方法

index

查看元素为1的index

>>a = (1,'zc')
>>a.index(1)
0

count

查看元素出现的次数

>>a = (1,'zc')
>>a.count(1)
1

元组和列表之间的相互转换，使用tuple和list方法:

>>a = [1,2,3]
>>b = tuple(a)
>>b
(1, 2, 3)
>>c = list(b)
>>c
[1, 2, 3]

推导式

各种推导式

[每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型] 遍历之后挨个处理

[满足条件的元素相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件] 筛选功能

列表推导式

例一：求10以内的偶数

ret = [i for i in range(1,11) if i%2 == 0 ]
print(ret)
#[2, 4, 6, 8, 10]

 例二：10以内可以被2整除的数的平方

ret = [i*i for i in range(1,11) if i%2 == 0]
print(ret)
# [4, 16, 36, 64, 100]

 例三:找到嵌套列表中名字含有两个‘e’的所有名字

names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
 ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
ret = [ name for lst in names for name in lst if name.count('e') >= 2]
print(ret)
# ['Jefferson', 'Wesley', 'Steven', 'Jennifer']

字典推导式

例一：将一个字典的key和value对调

mcase = {'a': 10, 'b': 34}
mcase_frequency = {mcase[k]: k for k in mcase}
print(mcase_frequency)
# {10:'a' , 34:'b'}

例二：合并大小写对应的value值，将k统一成小写

mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
mcase_frequency = {k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase}
print(mcase_frequency)
# {'a':17,'b':34,'z':3}

集合推导式

例：计算列表中每个值的平方，自带去重功能

squared = {x*x  for x in [1, -1, 2]}
print(squared)
# {1, 4}

三元运算符

三元运算（三目运算），是对简单的条件语句的缩写。

书写格式：

result = 值1 if 条件 else 值2 如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量

str_a = "hello"
ret = 1000 if len(str_a) >= 3 else 1
print(ret)
# 1000