python与java多线程 java和python多线程的区别

转载

mob64ca140ce312 2023-11-25 12:46:14

文章标签 python与java多线程 python java 字符串数据 文章分类 Python 后端开发

语法上的一些小差别

1. 注释类型
2. 变量定义方式
3. 输出方式
4. 不允许代码缩进？
5. 数据类型
6. 格式化输出
7. 输入函数
8. 强制类型转换
9. 运算符
10. 条件语句
11. 随机数
12. 三目运算符
13. 循环

13.1 while 循环
13.2 for 循环

14. 字符串
15. 字符串 - 切片
16. 字符串 - 查找
17. 字符串 - 修改
18. 列表
19. 列表的遍历
20. 列表嵌套
21. 元组 tuple
22. 字典
23. 集合
24. 公共操作符
25. 推导式

1. 注释类型

Java分为单行、多行、文档注释，分别是

//单行注释
	
	/*
	多行注释
	*/
	
	/**
	 * 文档注释
	 */
	```
而在 python 中 分为单行注释和多行注释


# 单行注释
"""
多行注释
"""
'''
这也是多行注释

2. 变量定义方式

Java 中 类型变量名 = 值;int i = 1; python 中 变量名= 值 i = 2 连分号都不要的！
那么 python 中就需要 判断数据类型(type()函数)：print(typr(i)) 输出 <class 'int'>

3. 输出方式

system.out.println(“Java”);
print(‘Python’)

python 中，print() 方法默认换行输出；
即 print(‘hello’,end="\n");
可自定义 print(‘hello’,end="\t");

4. 不允许代码缩进？

Java中代码自动会缩进
python 中手动代码缩进后，会报错 “unexpected indent” 意外缩进！

5. 数据类型

python 中数据类型，

python与java多线程 java和python多线程的区别_数据

6. 格式化输出

%s – 格式化输出字符串
%d – 格式化输出有符号的整数
%f – 格式化输出浮点数

age = 18
print(‘年纪%d岁’ % age) 18
print(‘年纪%03d岁’ % age) 018；
输入位数不足以0补齐，输入位数超过则原样子输出。

weight = 75.5
print(‘体重是%f千克’ % weight)
输出：体重是75.500000千克；默认保留 6 位小数

print(‘体重是%.1f千克’ % weight)
输出体重是 75.5千克

print(‘名字是%s，今年%d岁，体重%.2f公斤，学号%06d’ % (name,age,weight,id))
print(‘名字%s，年纪%s，体重%s’ % (name,age,weight))
print(f’名字{name}，年纪{age}岁’)

7. 输入函数

python 中，输入函数为 input(‘提示信息’)

特点：
当程序执行到input ，等待⽤用户输⼊，输入完成之后才继续向下执⾏。
在Python中， input 接收⽤用户输入后，⼀般存储到变量量，方便使用。
在Python中， input 会把接收到的任意⽤用户输⼊入的数据都当做 字符串 处理。

8. 强制类型转换

Java 中
String str = “123”;
int num = Integer.parseInt(str); -> 数值123；

python中
str2 = input(‘输入数字：’)
num2 = int(str2) -> 字符串转变成整型

类似的还有

1. float()
num3 = 1
f = float(num3) - > f = 1.0 注意不是 1.0000000

2. str()
3. tuple()
4. list()
5. eval（)：计算在字符串中的有效 Python 表达式，并返回一个对象

str2 = ‘1’
str3 = ‘1.2’

i = eval（str2) -> 即转换成了整数型 1
f = eval（str3) -> 即转换成了浮点型 1.2

9. 运算符

python 中

算数运算符
+-*/ 除 9/2 = 4.5 ; 结果为浮点型
// 整除 9//2 = 4
%** 指数 2**4 = 16
()
运算优先级：（）高于 ** 高于 *、/、//、% 高于 +、-
赋值运算符
多变量赋值：i,f,str = 1,1.0,‘name’
多变量赋相同的值 i = f = 1 重点在于，当后续修改 i 的值时，f 的值不变；不管是整数型还是字符串（或是list）
复合赋值运算符：+=、-=…
注意：当符合赋值运算符之后还有表达式，那么先算表达式，再算符合赋值运算符！如：

d = 10
d *= 2 + 1

输出结果为 30

比较运算符

//Java
age  > 18 && age <60

# Python
18 < age < 60

逻辑运算符
python 中包括 and、or、not
数字之间的逻辑运算：

and运算符，只要有⼀个值为0，则结果为0，否则结果为最后⼀个非0数字
or运算符，只有所有值为0结果才为0，否则结果为第⼀个非0数字

10. 条件语句

Java中：

if(bool){
	sout("T");
}else{
	sout("F");
}

Python 中

if b:
    print('T')
else:
    print('F')

对于多重判断不是 else if() 而是 elif

b = int(input("输入你的年纪："))
if b >60:
    print('老年人')
elif b > 18:
    print('成年人')
else:print('未成年人')

11. 随机数

import random
# Python；1 导包 2 使用
num = random.randint(0, 2)
print(num)

12. 三目运算符

//Java
int i = a < b ? a : b;

# Python
i = a if a < b else b

13. 循环

13.1 while 循环

i = 0
# 使用的是 while 但是发挥的作用与 Java 中 for 类似
while i < 100:
    num = random.randint(0, 2)
    print(f'第 {i} 个随机数：{num}')
    i+=1

while…else

# while 条件:
#     条件成⽴立重复执⾏行行的代码
# else:
#     循环正常结束之后要执⾏行行的代码


i = 1
while i <= 5:
	print('我爱北京天安门！')
	i += 1
else:
	print('喊完 5 遍，哈哈哈哈')

else 指的是循环正常结束之后要执行的代码，
即如果是break终.止循环的情况，else下.方缩进的代码将不执行。
continue 是退出当前⼀一次循环，继续下⼀一次循环，所以该循环在continue 控制下是可以正常结束的，当循环结束后，则执⾏行了 else 缩进的代码。

13.2 for 循环

# for 临时变量 in 序列列:
# 重复执行的代码1
# 重复执行的代码2
......
for i in 'Hello World':
    print(f'for() 循环 {i}')

for…else

# for 临时变量量 in 序列列:
#     重复执⾏行行的代码
#     ...
# else:
#     循环正常结束之后要执⾏行行的代码

使用 break / continue 跳出循环的处理方式跟 while…else 一致！

14. 字符串

一对引号字符串

# python
name1 = 'Tom'
name2 = "Rose"

三引号字符串

# python
name3 = ''' Tom '''
name4 = """ Rose """
a = ''' i am Tom,
nice to meet you! '''
b = """ i am Rose,
nice to meet you! """

注意：三引号形式的字符串串⽀支持换行。
思考：如果创建⼀一个字符串串I’m Tom ?

# python
c = "I'm Tom"
d = 'I\'m Tom'

15. 字符串 - 切片

Python 中序列[开始位置下标:结束位置下标:步长]

选区的区间为：左闭右开 [ )
步长默认是 1 ；可取负数；如果取 -1 那么就是倒序！反向取数据
开始、结束位置均可省略；如果取负数，那么 -1 表示从右数第一个数据，不管正负，都是左包右不包
如果取值区间为 -4，-1，-1，那么取出结果为空，因为从 -4 向右取到 -1 是可以的，但是 -1 表示反着取数据，自然取不出来。

16. 字符串 - 查找

find()：检测某个⼦子串串是否包含在这个字符串串中，如果在返回这个⼦子串串开始的位置下标，否则则返回-1。

# 字符串串序列列.find(⼦子串串, 开始位置下标, 结束位置下标)

index()：检测某个⼦子串串是否包含在这个字符串串中，如果在返回这个⼦子串串开始的位置下标，否则报异常。

# 字符串串序列列.index(⼦子串串, 开始位置下标, 结束位置下标)

count()；开始和结束位置下标可以省略略，表示在整个字符串串序列列中查找

# 字符串串序列列.count(⼦子串串, 开始位置下标, 结束位置下标)

rfind()：和find()功能相同，但查找⽅方向为右侧开始。
rindex()：和index()功能相同，但查找⽅方向为右侧开始。
count()：返回某个⼦子串串在字符串串中出现的次数

17. 字符串 - 修改

修改

replace()：替换
返回值 = 字符串串序列列.replace(旧⼦串, 新子串, 替换次数)
split()：按照指定字符分割字符串串。

# 字符串序列.split(分割字符, num) 
# 结果：['hello world ', ' itcast ', ' itheima ', ' Python']

如果分割字符是原有字符串中的⼦串，分割后则丢失该⼦串。

转换大小写

join() 插入；⽤用⼀一个字符或⼦子串串合并字符串串，即是将多个字符串串合并为⼀一个新的字符串串。

# 字符或⼦子串串.join(多字符串组成的序列)
list1 = ['chuan', 'zhi', 'bo', 'ke']
t1 = ('aa', 'b', 'cc', 'ddd')
# 结果：chuan_zhi_bo_ke
print('_'.join(list1))

capitalize()：转换字符串，使串中仅第一个字符转换成⼤写；其余都是小写
title()：将字符串 每个单词首字母 转换成⼤写。
lower()：将字符串中 所有大写 转小写。
upper()：将字符串中 所有小写 转⼤大写。

去除空白

lstrip()：删除字符串左侧空⽩字符。
rstrip()：删除字符串右侧空⽩字符。
strip()：删除字符串两侧空白字符。

对齐

ljust()：返回⼀个原字符串左对齐,并使用指定字符(默认空格)填充⾄至对应长度的新字符串。
rjust()：返回⼀一个原字符串串右对齐,并使用指定字符(默认空格)填充至对应长度的新字符串，语法和 ljust() 相同。
center()：返回⼀一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度的新字符串串，语法和ljust()相同。

判断

startswith()：检查字符串串是否是以指定⼦子串串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

# 字符串串序列列.startswith(⼦子串串, 开始位置下标, 结束位置下标)

endswith()：检查字符串是否是以指定⼦串结尾，是则返回True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

# 字符串串序列列.endswith(⼦子串串, 开始位置下标, 结束位置下标)

isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False。
isdigit()：如果字符串串只包含数字则返回 True 否则返回 False。
isalnum()：如果字符串至少有一个字符，并且所有字符都是 字母或数字 则返回 True,否则返回False。
isspace()：如果字符串中只包含空白，则返回 True，否则返回 False。

18. 列表

类似于 Java 中的数组
常见函数：均与字符串类似

index()
count()
len()
in：判断指定数据是否存在于某个列表序列，如果在返回 True，否则返回False

# Python
list =['Tom','Jack','Rose']
print('Tom' in list)

not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False
append()：列列表结尾追加数据。注意：如果append()追加的数据是一个序列，则将 整个序列 作为一个整体追加到列表
extend()：列列表结尾追加数据，如果数据是⼀个序列，则 将这个序列的数据逐一添加* 到列表。
insert()：指定位置新增数据。

列列表序列列.insert(位置下标, 数据)

删除列表： del 目标
删除指定数据：del name_list[0]

pop()：删除 指定下标的 数据(默认为最后⼀一个)，并返回 该数据。
remove()：移除列表中某个数据的 第一个匹配项。

# 列列表序列列.remove(数据)

clear()：清空列表：name_list.clear()
修改指定下标的值

name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'

逆置：reverse()

num_list.reverse()

排序：sort()

# 列表序列.sort( key=None, reverse=False)；参数可为空，
# 注意：reverse表示排序规则，reverse = True 降序， 
# reverse = False 升序（默认）

复制函数：copy()

name_li2 = name_list.copy()

19. 列表的遍历

while()

name_list = ['Tom', 'Lily', 'Rose']
i = 0
while i < len(name_list):
	print(name_list[i])
	i += 1

for()

name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
	print(i)

20. 列表嵌套

更像是二维数组，

name_list = [['⼩小明', '⼩小红', '⼩小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李李四','王五']]
# 第一步：按下标查找到李四所在的列表
print(name_list[2])
# 第二步：从李四所在的列表里⾯，再按下标找到数据李四
print(name_list[2][1])

21. 元组 tuple

一个元组可以存储多个数据，元组内的数据是不能修改的。

定义元组

# 多个数据元组
t1 = (10, 20, 30)
# 单个数据元组
t2 = (10,)
# 注意：如果定义的元组只有⼀个数据，
# 那么这个数据后⾯面也好添加逗号，
# 否则数据类型为唯⼀的这个数据的数据类型

元组的常见操作

# 按下标查找数据
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) # aa

# index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列列表、字符串串的index⽅方法相同。
print(tuple1.index('aa')) # 0

# count()：统计某个数据在当前元组出现的次数。
print(tuple1.count('bb')) # 2

# len()：统计元组中数据的个数。
print(len(tuple1)) # 4

注意：元组内的直接数据如果修改则立即报错；但是如果元组里面有列表，修改列表里面的数据则是支持的。

22. 字典

字典特点：
符号为⼤括号
数据为键值对形式出现
各个键值对之间⽤用逗号隔开
字典不支持下标

# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典
dict2 = {}
dict3 = dict()

字典的常见操作

增/改：字典序列列[key] = 值;

# 如果key存在则修改这个key对应的值；
# 如果key不不存在则新增此键值对。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'
# 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)
dict1['id'] = 110
# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)

删；del、clear

# del() / del：删除字典或删除字典中指定键值对。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['gender']
# 结果：{'name': 'Tom', 'age': 20}
print(dict1)

# clear()：清空字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1) # {}

查；key 查找、get()、keys()、values()、items()

# key值查找：如果当前查找的key存在，则返回对应的值；否则报错。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name']) # Tom
print(dict1['id']) # 报错

# get() 查找：字典序列列.get(key, 默认值)
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name')) # Tom
print(dict1.get('id', 110)) # 110
print(dict1.get('id')) # None

# keys()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# dict_keys(['name', 'age', 'gender'])
print(dict1.keys())

# values
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# dict_values(['Tom', 20, '男'])
print(dict1.values())

# items
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# dict_items([('name', 'Tom'), ('age', 20), ('gender',
'男')])
print(dict1.items())

遍历

# 遍历字典的key
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
	#输出
	# name
	# age
	# gender
	print(key)

# 遍历字典的value
for value in dict1.values():
	# 输出 
	# Tom 
	# 20
	# 男
	print(value)

# 遍历字典的元素；取出来的是元组
for item in dict1.items():
	#输出
	# ('name','Tom')
	# ('age','20')
	# ('gender','男')
	print(item)

# 遍历字典的键值对
for key, value in dict1.items():
	# 输出
	# name = Tom
	# age = 20
	# gender = 男
	print(f'{key} = {value}')

23. 集合

创建集合：
创建集合使用{} 或set() ，但是如果要创建空集合只能使用set() ，因为{} 用来创建空字典。

# 特点：
# 1. 集合可以去掉重复数据；
# 2. 集合数据是⽆无序的，故不不⽀支持下标

集合常⻅见操作⽅方法

增加数据

# add()
# 因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进⾏任何操作。
s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1) # {100, 10, 20}

# update(), 追加的数据是序列。并将序列拆开添加！
s1 = {10, 20}
# s1.update(100) # 报错
s1.update([100, 200])
s1.update('abc')
# {'a', 100, 200, 10, 'b', 20, 'c'}
print(s1)

删除数据

# remove()，删除集合中的指定数据，如果 >数据不存在则报错<。
s1 = {10, 20}
s1.remove(10)
print(s1)
s1.remove(10) # 报错
print(s1)

# discard()，删除集合中的指定数据，如果 >数据不存在也不会报错<。
s1 = {10, 20}
s1.discard(10)
print(s1)
s1.discard(10)
print(s1)

# pop()，>随机删除< 集合中的某个数据，并返回这个数据。
s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()
print(del_num)
print(s1)

查找数据

# in：判断数据在集合序列
# not in：判断数据不在集合序列

24. 公共操作符

运算符
公共方法

# range() 注意：range()⽣生成的序列列不不包含end数字。
# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
	print(i)
# 1 3 5 7 9
for i in range(1, 10, 2):
	print(i)
# 0 1 2 3 4 5 6 7 8 9
for i in range(10):
	print(i)

# enumerate()：enumerate(可遍历对象, start=0)
# start参数⽤用来设置遍历数据的下标的起始值，默认为0。
list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1):
	print(i)
for index, char in enumerate(list1, start=1):
	print(f'下标是{index}, 对应的字符是{char}')

容器类型转换
tuple()：将某个序列列转换成元组:

tuple(list1)
tuple(s1)

list()：将某个序列列转换成列表
set()：将某个序列转换成集合

25. 推导式

用一个表达式创建一个 有规律律的 列列表或控制一个有规律列表。

列表推导式

# 例子一：创建⼀一个0-10的列列表。

# while 循环
# 1. 准备⼀一个空列列表
list1 = []
# 2. 书写循环，依次追加数字到空列列表list1中
i = 0
while i < 10:
list1.append(i)
i += 1
print(list1)

# for 循环
list1 = []
for i in range(10):
list1.append(i)
print(list1)

# 列表推导式
list1 = [i for i in range(10)]
print(list1)

带if的列列表推导式

# 创建 0-10 的偶数列列表
# 方法一：range()步⻓长实现
list1 = [i for i in range(0, 10, 2)]
print(list1)

# ⽅法二：if实现
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)

多个for循环实现列列表推导式

# 创建列列表如下：
# [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)

字典推导式

# 例一：创建一个字典：字典key是1-5数字，value是这个数字的2次方。
dict1 = {i: i**2 for i in range(1, 5)}
# {1: 1, 2: 4, 3: 9, 4: 16}
print(dict1)

# 例二：将两个列列表合并为⼀一个字典
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)

# 例三：提取字典中⽬目标数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
# 需求：提取上述电脑数量量⼤大于等于200的字典数据
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1) # {'MBP': 268, 'DELL': 201}

集合推导式

# 创建一个集合，数据为下⽅方列列表的2次方。集合有数据去重功能。
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1) # {1, 4}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：spring boot 服务集群负载均衡 springboot项目集群部署

下一篇：python 从字符串中解析到最后一个 aaa 后面的字符串 python字符串hiandy中a的位置

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯