Python和Java的一些小差别

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 中数据类型，

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 中

1. 算数运算符
   +
-
*
/ 除 9/2 = 4.5 ; 结果为浮点型
   // 整除 9//2 = 4
   %
** 指数 2**4 = 16
   ()
   运算优先级：（）高于 ** 高于 *、/、//、% 高于 +、-

2. 赋值运算符

   多变量赋值：i,f,str = 1,1.0,‘name’
   多变量赋相同的值 i = f = 1 重点在于，当后续修改 i 的值时，f 的值不变；不管是整数型还是字符串（或是list）

3. 复合赋值运算符：+=、-=…
   注意：当符合赋值运算符之后还有表达式，那么先算表达式，再算符合赋值运算符！如：

   d = 10
   d *= 2 + 1
   

   输出结果为 30

4. 比较运算符

   //Java
   age  > 18 && age <60
   

   # Python
   18 < age < 60
   

5. 逻辑运算符

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

   1. and运算符，只要有⼀个值为0，则结果为0，否则结果为最后⼀个非0数字
   2. 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. 选区的区间为：左闭右开 [ )
2. 步长默认是 1 ；可取负数；如果取 -1 那么就是倒序！反向取数据
3. 开始、结束位置均可省略；如果取负数，那么 -1 表示从右数第一个数据，不管正负，都是左包右不包
4. 如果取值区间为 -4，-1，-1，那么取出结果为空，因为从 -4 向右取到 -1 是可以的，但是 -1 表示反着取数据 ，自然取不出来。

16. 字符串 - 查找

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

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

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

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

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

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

4. rfind()： 和find()功能相同，但查找⽅方向为右侧开始。

5. rindex()：和index()功能相同，但查找⽅方向为右侧开始。

6. count()：返回某个⼦子串串在字符串串中出现的次数

17. 字符串 - 修改

修改

1. replace()：替换
   返回值 = 字符串串序列列.replace(旧⼦串, 新子串, 替换次数)

2. split()：按照指定字符分割字符串串。

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

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

转换大小写

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

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

4. capitalize()：转换字符串，使串中 仅 第一个字符转换成⼤写；其余都是小写

5. title()：将字符串 每个单词首字母 转换成⼤写。

6. lower()：将字符串中 所有大写 转小写。

7. upper()：将字符串中 所有小写 转⼤大写。

去除空白

8. lstrip()：删除字符串 左侧空⽩ 字符。
9. rstrip()：删除字符串 右侧空⽩ 字符。
10. strip()：删除字符串 两侧空白 字符。

对齐

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

判断

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

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

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

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

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

18. 列表

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

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

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

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

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

9. del
   1. 删除列表： del 目标
   2. 删除指定数据：del name_list[0]
10. pop()：删除 指定下标的 数据(默认为最后⼀一个)，并返回 该数据。
11. remove()：移除列表中某个数据的 第一个匹配项。

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

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

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

14. 逆置：reverse()

    num_list.reverse()
    

15. 排序：sort()

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

16. 复制函数：copy()

    name_li2 = name_list.copy()
    

19. 列表的遍历

1. while()

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

2. 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

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

1. 定义元组

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

2. 元组的常见操作

   # 按下标查找数据
   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. 字典

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

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

2. 字典的常见操作

   1. 增/改：字典序列列[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)
   

   2. 删；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) # {}
   

   3. 查；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())
   

   4. 遍历

   # 遍历字典的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. 集合

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

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

2. 集合常⻅见操作⽅方法

   1. 增加数据

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

3. 删除数据

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

4. 查找数据

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

24. 公共操作符

1. 运算符
   

2. 公共方法
   

   # 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}')
   

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

   tuple(list1)
   tuple(s1)
   

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

25. 推导式

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

1. 列表推导式

   # 例子一：创建⼀一个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)
   

2. 字典推导式

   # 例一：创建一个字典：字典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}
   

3. 集合推导式

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

---