day04 基本数据类型与基本运算符

Posted 2023-05-16 Dream-Z

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了day04 基本数据类型与基本运算符相关的知识，希望对你有一定的参考价值。

【四】基本数据类型

我们学习变量是为了让计算机能够像人一样去记忆事物的某种状态
- 而变量的值就是用来存储事物状态的，很明显事物的状态分成不同种类的（比如人的年龄，身高，职位，工资等等）
- 所以变量值也应该有不同的类型，例如

salary = 3.1 		# 用浮点型去记录薪资 
age = 18     		# 用整型去记录年龄 
name = \'lili\'   # 用字符串类型去记录人名

【1】数字类型

（1）整形（int）

(1.1)作用

用来记录人的年龄，出生年份，学生人数等整数相关的状态

(1.2)定义

age=18 

birthday=1990 

student_count=48

（2）浮点型（float）

(2.1)作用

用来记录人的身高，体重，薪资等小数相关的状态

(2.2)定义

height=172.3 

weight=103.5 

salary=15000.89

（3）数字类型的应用

(3.1)数字运算

>>> a = 1 
>>> b = 3 
>>> c = a + b 
>>> c 
4

(3.2)比较大小

>>> x = 10 
>>> y = 11
>>> x > y
False

【2】字符串（str）

（1）作用

用来记录人的名字，家庭住址，性别等描述性质的状态
用来记录描述性信息
- eg：姓名地址邮箱...

（2）定义方式

	方式1：
    	name = \'kevin\'
    方式2：
    	name = "kevin"
    方式3：
    	name = \'\'\'kevin\'\'\' # (当左边有赋值符号和遍历名的时候，它就是字符串)
    方式4：
    	name = """kevin""" # (当左边有赋值符号和遍历名的时候，它就是字符串)

# ps：用引号引起来的部分

对于变量名的值
- 用单引号、双引号、多引号，都可以定义字符串
- 本质上是没有区别的

但是

1、需要考虑引号嵌套的配对问题
```
msg = "My name is Tony , I\'m 18 years old!,hope your life : \'wonderful!\'" 

msg = \'My name is Tony , I\'m 18 years old!,hope your life : "wonderful!"\'
```
\'\'\'注意：当有引号套用的情况下，外面是单引号里面就要是双引号，外面是双引号里面就要是单引号\'\'\'

2、多引号可以写多行字符串

msg = \'\'\'         
	天下只有两种人。比如一串葡萄到手，一种人挑最好的先吃，另一种人把最好的留到最后吃。
    照例第一种人应该乐观，因为他每吃一颗都是吃剩的葡萄里最好的；
    第二种人应该悲观，因为他每吃一颗都是吃剩的葡萄里最坏的。 
    不过事实却适得其反，缘故是第二种人还有希望，第一种人只有回忆。 
\'\'\'

（3）使用

数字可以进行加减乘除等运算
字符串呢？
- 也可以，但只能进行"相加"和"相乘"运算。

>>> name = \'tony\' 
>>> age = \'18\' 
>>> name + age  #相加其实就是简单的字符串拼接 
\'tony18\' 
>>> name * 5 #相乘就相当于将字符串相加了5次 
\'tonytonytonytonytony\'

【3】列表（list）

（1）作用

用来存取多个相同属性的值，并且方便存取
如果我们需要用一个变量记录多个学生的姓名，用数字类型是无法实现，字符串类型则可以记录下来
比如
```
# 字符串类型
stu_names=’张三 李四 王五’
# 列表类型
names_list = [\'张三\', \'李四\', \'王五\']
```
- 存的目的是为了取，此时若想取出第二个学生的姓名实现起来相当麻烦
- 而列表类型就是专门用来记录多个同种属性的值（比如同一个班级多个学生的姓名、同一个人的多个爱好等），并且存取都十分方便

（2）定义

>>> stu_names=[\'张三\',\'李四\',\'王五\']

（3）使用

1、列表类型是用索引来对应值，索引代表的是数据的位置，从0开始计数

>>> stu_names=[\'张三\',\'李四\',\'王五\'] 
>>> stu_names[0]  
\'张三\' 
>>> stu_names[1] 
\'李四\' 
>>> stu_names[2] 
\'王五\'

2、列表可以嵌套，嵌套取值如下

l = [1, 1.1, \'kevin\', [666, 777, 888, \'tony\', [22,33, \'kevinNB\']]]

# 1. kevinNB在大列表的第几个位置
l1 = l[3]  # [666, 777, 888, \'tony\', [22, 33, \'kevinNB\']]

# 2. kevinNB在大列表的第几个位置
l2 = l1[4] # [22, 33, \'kevinNB\']

# 3. kevinNB在大列表的第几个位置
l3 = l2[2]  # kevinNB
print(l3)
# 整合
l4 = l[3][4][2]
print(l4)

【4】字典（dict）

（1）作用

如果我们需要用一个变量记录多个值，但多个值是不同属性的
- 比如人的姓名、年龄、身高，用列表可以存，但列表是用索引对应值的，而索引不能明确地表示值的含义
- 这就用到字典类型，字典类型是用 key：value 形式来存储数据
  - 其中key可以对value有描述性的功能，能够明确的描述详细信息

（2）定义

定义：大括号括起来，内部可以存放多个元素，元素与元素之间使用逗号隔开，是以K:V键值对的形式存储
- K:
  - 是对V的描述性信息（一般情况是字符串）
- V:
  - 真正的数据，其实相当于变量值,也是任意的数据类型

>>> person_info=\'name\':\'tony\',\'age\':18,\'height\':185.3

（3）使用

1、字典类型是用key来对应值，key可以对值有描述性的功能，通常为字符串类型

字典不能通过索引取值，只能通过字典的K取值

>>> person_info=\'name\':\'tony\',\'age\':18,\'height\':185.3 
>>> person_info[\'name\'] 
\'tony\' 
>>> person_info[\'age\'] 
18 
>>> person_info[\'height\'] 
185.3

2、字典可以嵌套，嵌套取值如下

info = 
    \'username\':\'tony\',
    \'addr\':
        \'国家\':\'中国\',
        \'info\':[666, 999, \'编号\':466722, \'hobby\':[\'read\', \'study\', \'music\']]
    


# 1. music在大字典里的位置
d1 = info[\'addr\'] # \'国家\': \'中国\', \'info\': [666, 999, \'编号\': 466722, \'hobby\': [\'read\', \'study\', \'music\']]

# 2. music在小字典里的位置
d2 = d1[\'info\']  # [666, 999, \'编号\': 466722, \'hobby\': [\'read\', \'study\', \'music\']]

# 3. music在列表里的位置
d3 = d2[2]  # \'编号\': 466722, \'hobby\': [\'read\', \'study\', \'music\']

# 4. music在小字典里的位置
d4 = d3[\'hobby\']  # [\'read\', \'study\', \'music\']

# 5. music在列表里的位置
d5 = d4[2] # music
print(d5)

# 整合
d6 = info[\'addr\'][\'info\'][2][\'hobby\'][2]
print(d6)

【5】布尔（bool）

（1）作用

用来记录真假的状态
判断是否正确

（2）定义

只有两种情况
- True
  - 对正确的可行的...
- False
  - 错误不可行的

>>> is_ok = True 
>>> is_ok = False

在python中，什么是真，什么是假?
- 哪些是假的情况：
  - 0,
  - None,
  - \'\',
  - [],
  - ...
- 其他都是真

（3）使用

布尔值的命名规范：结果可能是布尔值的情况，我们都采用 is 开头 命名
- is_right
- is_delete
通常用来当作判断的条件，我们将在if判断中用到它
在python中，所有的数据类型都可以转为布尔值

【6】元祖（tuple）

（1）作用

用来存取多个相同属性的值，并且方便存取
如果我们需要用一个变量记录多个学生的姓名，用数字类型是无法实现，字符串类型则可以记录下来
列表可以改变里面的值，但是元祖里面的值不能被改变

（2）定义

小括号括起来，内部可以存放多个元素，元素与元素之间使用逗号隔开，元素不能更改

t1 = (11, 22, 33, 44)

【7】集合（set）

（1）作用

集合（set）是一个无序的不重复元素序列。

（2）定义

可以使用大括号或者 set() 函数创建集合

注意：创建一个空集合必须用 set() 而不是，因为是用来创建一个空字典。

大括号括起来，内部可以存放多个元素，元素与元素之间逗号隔开，但是不是K:V键值对的形式
- 创建方式一
```
s = 11,22,33,44
```
- 创建方式二
```
set(value)
```

集合中的元素不能直接取出

【五】程序与用户交互

【1】程序与用户交互

（1）什么是与用户交互

用户交互就是人往计算机中input/输入数据，计算机print/输出结果

（2）为什么要与用户交互

为了让计算机能够像人一样与用户沟通交流
比如
- 过去我们去银行取钱，用户需要把帐号密码告诉柜员
- 而现在，柜员被ATM机取代
  - ATM机就是一台计算机
  - 所以用户同样需要将帐号密码告诉计算机
  - 于是我们的程序中必须有相应的机制来控制计算机接收用户输入的内容
  - 并且输出结果

（3）如何与用户交互

交互的本质就是输入、输出

(3.1)输入（input）

在python3中input功能会等待用户的输入

用户输入任何内容

input接受的所有数据类型都是 str 类型

# 输入input

password = input(\'请输入你的密码:>>>\')
print(password, type(password)) # input接受的所有数据类型都是str类型
# print(password == \'123\')   # python中 == 比较的是数据值和数据类型
print(int(password) == 123)  # python中 == 比较的是数据值和数据类型
print(password == str(123))  # python中 == 比较的是数据值和数据类型

然后赋值给等号左边的变量名

>>> username=input(\'请输入您的用户名：\') 
请输入您的用户名：jack # username = "jack"
>>> password=input(\'请输入您的密码：\') 
请输入您的密码：123 # password = "123"

1、在python2中
- 存在一个raw_input功能与python3中的input功能一模一样

2、在python2中

还存在一个input功能

需要用户输入一个明确的数据类型，输入什么类型就存成什么类型

>>> l=input(\'输入什么类型就存成什么类型: \')
输入什么类型就存成什么类型: [1,2,3]
>>> type(l)
<type \'list\'>

(3.2)输出（print）

>>> print(\'hello world\')  # 只输出一个值
hello world
>>> print(\'first\',\'second\',\'third\')  # 一次性输出多个值，值用逗号隔开
first second third

默认print功能有一个 end 参数
- 该参数的默认值为"\\n"(代表换行)，可以将end参数的值改成任意其它字符

print("aaaa",end=\'\')
print("bbbb",end=\'&\')
print("cccc",end=\'@\')
#整体输出结果为：aaaabbbb&cccc@

(3.3)输出之格式化输出

[3.3.1] 什么是格式化输出
- 把一段字符串里面的某些内容替换掉之后再输出，就是格式化输出。
[3.3.2] 为什么要格式化输出
- 我们经常会输出具有某种固定格式的内容
  - 比如：\'亲爱的xxx你好！你xxx月的话费是xxx，余额是xxx‘
- 我们需要做的就是将xxx替换为具体的内容。

[3.3.3] 如何格式化输出

这就用到了占位符，如：

可以接收任意类型的值

# %s称为占位符（掌握）可以为所有的数据类型占位
res = \'亲爱的%s你好！你%s月的话费是%s，余额是%s，我们需要做的就是将xxx替换为具体的内容。\'
print(res % (\'kevin\', 99, 2, 99999999))  # 亲爱的kevin你好！你99月的话费是2，余额是99999999，我们需要做的就是将xxx替换为具体的内容。
print(res % (\'kevin1\', 991, 2, 100))  # 亲爱的kevin1你好！你991月的话费是2，余额是100，我们需要做的就是将xxx替换为具体的内容。
print(res % (\'kevin2\', 992, 2, 1199999))  # 亲爱的kevin2你好！你992月的话费是2，余额是1199999，我们需要做的就是将xxx替换为具体的内容。
print(res % (\'kevin3\', 993, 2, 22999999))  # 亲爱的kevin2你好！你992月的话费是2，余额是1199999，我们需要做的就是将xxx替换为具体的内容。
print(res % (\'kevin4\', 994, 2, 933999999))  # 亲爱的kevin4你好！你994月的话费是2，余额是933999999，我们需要做的就是将xxx替换为具体的内容。

res1 = \'my name is %s\'
print(res1 % \'tony\')  # my name is tony

只能接收数字

# %d占位符（了解）只能给数字类型占位
# print("my name is %d" % \'kevin\') # TypeError: %d format: a number is required, not str

print("金额：%08d" % 111) # 金额：00000111
print("金额：%08d" % 666666) # 金额：00666666
print("金额：%08d" % 99999999999) # 金额：99999999999

[3.3.4] 练习:接收用户输入，打印成指定格式

name = input(\'your name: \')
age = input(\'your age: \') #用户输入18,会存成字符串18,无法传给%d
print(\'My name is %s,my age is %s\' %(name,age))

[3.3.5] 练习:用户输入姓名、年龄、工作、爱好，然后打印成以下格式

------------ info of Tony -----------
Name  : Tony
Age   : 22
Sex   : male
Job   : Teacher 
------------- end -----------------

【六】基本运算符

参考网站（菜鸟教程）：https://www.runoob.com/python/python-operators.html

【1】算数运算符

python支持的算数运算符与数学上计算的符号使用是一致的
- 我们以x=9，y=2为例来依次介绍它们

python中拼接字符串使用 +

s1 = \'hello\'
s2 = \'world\'
print(s1 + s2)  # helloworld
print(s1 * 10)  # hellohellohellohellohellohellohellohellohellohello

【2】比较运算符

比较运算用来对两个值进行比较，返回的是布尔值True或False
- 我们以x=9，y=2为例来依次介绍它们

【3】赋值运算符

python语法中除了有=号这种简单的赋值运算外
还支持增量赋值、链式赋值、交叉赋值、解压赋值
这些赋值运算符存在的意义都是为了让我们的代码看起来更加精简。
- 我们以x=9，y=2为例先来介绍一下增量赋值

（1）增量运算符

（2）链式赋值

如果我们想把同一个值同时赋值给多个变量名，可以这么做

>>> z=10
>>> y=z
>>> x=y
>>> x,y,z
(10, 10, 10)

链式赋值指的是可以用一行代码搞定这件事

>>> x=y=z=10
>>> x,y,z
(10, 10, 10)

（3）交叉赋值

我们定义两个变量m与n

>>> m=10
>>> n=20

如果我们想将m与n的值交换过来，可以这么做

>>> temp=m
>>> m=n
>>> n=temp
>>> m,n
(20, 10)

交叉赋值指的是一行代码可以搞定这件事

>>> m=10
>>> n=20
>>> m,n=n,m # 交叉赋值
>>> m,n
(20, 10)

（4）解压赋值

如果我们想把列表中的多个值取出来依次赋值给多个变量名
- 可以这么做

>>> nums=[11,22,33,44,55]
>>> 
>>> a=nums[0]
>>> b=nums[1]
>>> c=nums[2]
>>> d=nums[3]
>>> e=nums[4]
>>> a,b,c,d,e
(11, 22, 33, 44, 55)

左右两边的多个值进行赋值时

个数必须一致

names_list = [\'kevin\', \'tony\', \'tank\', \'tom\']

# ll1, ll2, ll3, ll4 = names_list
# ll1, ll2, ll3, ll4 = [\'kevin\', \'tony\', \'tank\', \'tom\']

解压赋值指的是一行代码可以搞定这件事

>>> a,b,c,d,e=nums # nums包含多个值，就好比一个压缩包，解压赋值因此得名
>>> a,b,c,d,e
(11, 22, 33, 44, 55)

注意，上述解压赋值，等号左边的变量名个数必须与右面包含值的个数相同,否则会报错

1、变量名少了

>>> a,b=nums
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

2、变量名多了

>>> a,b,c,d,e=nums # nums包含多个值，就好比一个压缩包，解压赋值因此得名
>>> a,b,c,d,e,f=nums
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 6, got 5)

但如果我们只想取头尾的几个值，可以用*_匹配

>>> a,b,c,d,e=nums # nums包含多个值，就好比一个压缩包，解压赋值因此得名
>>> a,b,*_=nums
>>> a,b
(11, 22)

可以用 * 代替一个集合,将一堆数据取出来

ll1, *a, ll3, ll4 = [\'kevin\', \'tony\', \'tank\',\'a\',\'b\', \'tom\']

print(ll1, a, ll4) # kevin [\'tony\', \'tank\', \'a\'] tom

ps：字符串、字典、元组、集合类型都支持解压赋值

（5）逻辑运算符

逻辑运算符用于连接多个条件
- 进行关联判断
- 会返回布尔值True或False

(5.1)连续多个 `and`

可以用and连接多个条件
- 会按照从左到右的顺序依次判断
- 一旦某一个条件为False
  - 则无需再往右判断
  - 可以立即判定最终结果就为False
- 只有在所有条件的结果都为True的情况下
  - 最终结果才为True。

>>> 2 > 1 and 1 != 1 and True and 3 > 2 # 判断完第二个条件，就立即结束，得的最终结果为False
False

(5.2)连续多个 `or`

可以用or连接多个条件
- 会按照从左到右的顺序依次判断
- 一旦某一个条件为True
  - 则无需再往右判断
  - 可以立即判定最终结果就为True
- 只有在所有条件的结果都为False的情况下
  - 最终结果才为False

>>> 2 > 1 or 1 != 1 or True or 3 > 2 # 判断完第一个条件，就立即结束，得的最终结果为True
True

(5.3)优先级 `not>and>or`

1、三者的优先级关系： not>and>or
- 同一优先级默认从左往右计算。
```
>>> 3>4 and 4>3 or 1==3 and \'x\' == \'x\' or 3 >3
False
```
2、最好使用括号来区别优先级，其实意义与上面的一样
- (1) not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割
- (2) 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可
- (3) 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算
```
>>> (3>4 and 4>3) or (1==3 and \'x\' == \'x\') or 3 >3
False 
```

3、短路运算：

逻辑运算的结果一旦可以确定
那么就以当前处计算到的值作为最终结果返回

>>> 10 and 0 or \'\' and 0 or \'abc\' or \'egon\' == \'dsb\' and 333 or 10 > 4
我们用括号来明确一下优先级
>>> (10 and 0) or (\'\' and 0) or \'abc\' or (\'egon\' == \'dsb\' and 333) or 10 > 4
短路：       0      \'\'            \'abc\'                    
            假     假              真

返回：                            \'abc\'

4、短路运算面试题：

>>> 1 or 3
1
>>> 1 and 3
3
>>> 0 and 2 and 1
0
>>> 0 and 2 or 1
1
>>> 0 and 2 or 1 or 4
1
>>> 0 or False and 1
False

（6）成员运算符

注意：虽然下述两种判断可以达到相同的效果，但我们推荐使用第二种格式，因为not in语义更加明确

>>> not \'lili\' in [\'jack\',\'tom\',\'robin\']
True
>>> \'lili\' not in [\'jack\',\'tom\',\'robin\']
True

（7）身份运算符

需要强调的是：
- == 双等号比较的是value是否相等
- is 比较的是id是否相等

id相同，内存地址必定相同，意味着type和value必定相同
value相同type肯定相同，但id可能不同,如下

>>> x=\'Info Tony:18\'
>>> y=\'Info Tony:18\'
>>> id(x),id(y) # x与y的id不同，但是二者的值相同
(4327422640, 4327422256)

>>> x == y # 等号比较的是value
True
>>> type(x),type(y) # 值相同type肯定相同
(<class \'str\'>, <class \'str\'>)
>>> x is y # is比较的是id，x与y的值相等但id可以不同
False

java基础语法学习day03---初学者必看详解

一、数据类型

1、基本数据类型

java分基本数据类型和引用数据类型
  基本数据类型只有8种
  4个整数2个小数2个非数
1)byte (字节) 1字节  -128~127
  不常用(IO学习时使用)

2)short(短整型) 2字节 -32768~32767
  不常用(和其他语言兼容使用)

3)int  (整型)   4字节  -21亿~21亿
  最常用的类型

4)long (长整型) 8字节  很大
  较常用(int类型不够用时使用)
  当赋值的数值大于int的取值范围时
  需要在这个值的后面加l或L

5)float (单精度) 4字节
  不常用,精度不足
  正常赋值时,
  如果赋小数值,需要在小数值
  后加f或F

6)double(双精度) 8字节
  常用
  精度较高

7)char (字符) 2字节  0~65535
  保存一位字符
  而且有且只有一位
  'a'  --  97
  'A'  --  65
  '0'  --  48
  
  特殊字符:转义符:\\
  '    --  \\'
  \\    --  \\\\

8)boolean (布尔)  1字节
  取值只有true或false

2、数据类型转化

byte------short-----int——long-----float———double

char——

自动类型转化（隐式类型的转化）

从小类型到大类型是可以自动完成。
强制类型转化（显式类型的转化）

从大类型转小类型，需要进行强制转化符

(需要转化成的类型)变量

但是这样的话，可能会造成数据精度丢失或者溢出。

2.1、基本数据类型的注意事项

1)java中的数据直接量
在java代码中直接写出的数值
整数直接量是int类型
小数直接量是double类型
2)数据的溢出
当一个数据类型的变量接收了
大于自己范围的数据
就会产生溢出,这个现象不是
我们想看到的,所以了解即可,
不用研究
3)时间偏移量
1970-1-1 00:00
开始到程序运行时经过的毫秒数
long time=System.currentTimeMillis();
4)舍入误差
浮点型的计算可能会发生
计算结果不精确的情况
需要使用今后学习的引用类型解决
现阶段只需要了解这个现象就可以了

案例：

package cn.tedu.day06;

public class DataTypeChange {
	
	public static void main(String[] args) {
		
		int x = 5;
		
		//int---byte
		byte b = 56;
		System.out.println(b);
		//（要强转的类型）变量
		byte b1 = (byte)128;
		System.out.println(b1);
		
		//1、自动类型的转化
		int x1 = 5;
		int y1 = 6;
		long z = x1 + y1;
		System.out.println(z);//long
		
		long l1 = 1024l;
		//2、强转的时候，如果数据在转化范围内，就不会发生数据溢出
		int i = (int) l1;//强制转化
		
		long l2 = 1024l * 1024 * 1024 * 4;
		int i2 = (int)l2;//会发生溢出
		System.out.println(i2);//0  
		
		double pi = 3.1415926578976588;
		float f = (float) pi;//会造成精度的损失
		System.out.println(f);//3.1415927
		
		//3、数据类型运算的时候，自动类型的转化
		long hm = 365 * 24 * 60 * 60 * 1000;
		
		double d = 800 - 600.5;
		System.out.println(d);//199.5
		
		double d2 = 80 / 100;
		System.out.println(80 / 100);//0
		System.out.println(d2);//0.0
		
		double d3 = 80.0 / 100;
		System.out.println(d3);//0.8
		//多种基本数据类型参与运算的时候，结果会发生自动类型的转化。
		
	}
}

Byte/char/short——>int
- int直接量可以直接赋值给byte、char和short，只要不超过表示的范围。
```
char c = 65;
byte b = 45;
short s = 23;
```
- byte、char、short三种类型参与运算的时候，先进行转化为int类型，再参与运算。

2.2、数据类型的转换

1)java中运行计算的原则
java中只允许相同数据类型的数据
发生计算,计算结果还是这个类型

2)自动类型转换(隐式类型转换)
当不同数据类型的数据发生计算时
java系统会自动将较小的数据类型
转换成较大的数据类型
,计算结果是较大的数据类型

小大
byte short int long float double
char
1.float类型比long类型大
2.byte\\short\\char计算结果都是int
3)强制类型转换(显式类型转换)
由程序员编写代码
将一个数据转成指定的类型
(<类型>)<变量\\数值>
double d=12.5;
int i=(int)d;//12.5–>12
强制类型转换可能造成精度丢失
当两个不同数据类型的数据计算时
想要较小的数据类型的结果

二、运算符

1、算术运算符

+ - *  /
    
%
++ -- 

    package cn.tedu.day06;
/**
 * 运算符
 * @author zhangjian
 *
 */
public class OperatorDemo {
	
	public static void main(String[] args) {
		//1.算术运算符
		System.out.println(3 + 2);//5
		System.out.println(3 - 2);//1
		System.out.println(3 * 2);//6
		System.out.println(3 / 2);//1
		//发生异常-java.lang.ArithmeticException 算术异常
		//System.out.println(3 / 0);
		
		//% 参与运算的时候，结果的正负与%符号左边的正负有关系。
		System.out.println(5 % 3);//2
		System.out.println(-5 % 3);//-2
		System.out.println(-5 % -3);//-2
		System.out.println(5 % -3);//2
		
		//++ --
		int x = 5;
		x++;//x = x + 1;
		System.out.println(x);//6
		++x;//x = x + 1;
		System.out.println(x);//7
		
		x--;
		System.out.println(x);//6
		--x;//x = x - 1;
		System.out.println(x);//5
		
		//a++  后增
		/*
		 * 当a++后增,参与运算的时候，先进行参与运算，后进行自增。
		 */
		int a = 6;
		int b = a++;
		System.out.println("a = " + a + ",b = " + b);//a = 7,b = 6
		/*
		 * ++m 前增
		 * 当++前增，参与运算的时候，先进行自增，再参与运算。
		 */
		int m = 6;
		int n = ++m;//先进行++m，得到m=7，后将m=7赋值给n,得到n=7
		System.out.println("m = " + m + ",n = " + n);//7 7
		
		int p = 6;
		int q = p--;
		System.out.println("p = " + p + ",q = " + q);//5 6
		
		int i = 8;
		int j = 7;
		i = --j;//i = 6; j = 6
		System.out.println("i = " + i + ",j = " + j);
		j = ++i;//i = 7;j = 7;
		System.out.println("i = " + i + ",j = " + j);
	}
}

2、赋值运算符

= 赋值运算符，用于对变量进行赋值。把=右边的值赋值给左边的变量。

OperatorDemo01

复合的赋值运算符

-=

*=

package cn.tedu.day07;
/**
 * 赋值运算符：=
 * @author zhangjian
 */
public class OperatorDemo01 {
	
	public static void main(String[] args) {
		//
		int num = 19, index;
		System.out.println(num);
		System.out.println(index = num % 3);//1
		System.out.println(index);//1
		
		int x, y, z;
		x = y = z = 66;
		System.out.println(z);//66
		
		//复合赋值运算
		x += 5;//计算的时候：x = x + 5;
		System.out.println(x);//x=71
		
		x -= 5;//x = x - 5;
		System.out.println(x);//x = 66
		
	}
	
}

3、关系运算符

用来判断数据之间的大小关系。

包括：大于、小于、等于(==)、大于等于(>=)、小于等于、不等于(!=)六种运算符。

关系运算符的判断结果为：boolean类型的。关系成立结果为true，关系不成立结果为false。

OperatorDemo02

package cn.tedu.day07;
/**
 * 关系运算符：
 * @author zhangjian
 *
 */
public class OperatorDemo02 {
	public static void main(String[] args) {
		int max = 30;
		int num1 = 6;
		boolean b1 = max > 35;//false
		boolean b2 = num1 % 2 == 0;//true
		boolean b3 = num1 % 2 != 0;//false
		System.out.println(b1);
		System.out.println(b2);
		System.out.println(b3);
	}
}

4、连接运算符

使用 + 进行字符串的连接。

字符串：双引号引起来的 “ ”

OperatorDemo03

package cn.tedu.day07;
/**
 * 连接运算符：+
 * @author zhangjian
 *
 */
public class OperatorDemo03 {
	
	public static void main(String[] args) {
		
		//love520
		System.out.println("love520");
		int num = 1314;
		//love1314
		System.out.println("love" + num);//love1314
		//love1314520  ---- love1314 + 520 ---love1314520
		System.out.println("love" + num + 520);
		//love1834  ()优先级  优先计算括号里面的
		System.out.println("love" + (num + 520));
		
		System.out.println(520 + "love");//520love
		System.out.println(520 + 1314 + "love");//1834love
		System.out.println(520 + (1314 + "love"));//5201314love
		
		String msg = "love";
		msg = 520 + 1314 + msg + 521 + 1314;
		System.out.println(msg);//1834love5201314
		
		msg = "love";
		msg = 520 + (1314 + msg + 521) + 1314;
		System.out.println(msg);//5201314love5211314
		
	}

}

5、逻辑运算符

建立在关系运算之上的，包括：与&& 或 || 非 |

运算结果为：boolean类型的。

变量b1	变量b2	b1&&b2	b1\|\|b2	!b1
true	True	True	True	False
True	False	False	True	false
False	True	False	True	True
False	false	False	False	true

使用&&运算符：

两个boolean类型的值，参与&&运算的时候，只有两边都为true的时候，结果才为true；

真真为真。

OperatorDemo04

package cn.tedu.day07;
/**
 * && || ！
 * 逻辑运算符：
 * @author zhangjian
 *
 */
public class OperatorDemo04 {
	
	public static void main(String[] args) {
		int score = 58;
		//小明参加考试，如果考试成绩在80到100之间，奖励个四大名著一部。
		//  80 <= score <= 100
		boolean b = score >= 80 && score <= 100;
		//score >= 80  score <= 100 关系运算  boolean  
		System.out.println(b);//false
		
		//会唱歌或者会跳舞
		boolean sing = true;
		boolean dance = false;
		boolean b2 = sing || dance;
		System.out.println(b2);
		
		int x = 5;
		boolean b4 = sing || x++ > 3;
		System.out.println(b4);
		System.out.println(x);
		
		/*int m = 100;
		int n = 200;
		boolean b5 = (m > n) || (m++ > 200);
		System.out.println(b5);//false
		System.out.println(m);*/
		
		//短路逻辑
		int m = 100;
		int n = 200;
		boolean b5 = (m > n) && (m++ > 200);
		System.out.println(b5);//false
		System.out.println(m);//m = 100,不执行
		
		//! 非
		boolean isRain = true;
		boolean b7 = !isRain;
		System.out.println(b7);
	}
}

6、三元/目运算符

回顾：

1、JDK/JRE/JVM

2、跨平台

3、java环境变量的配置

4、Eclipse的使用

5、关键字

6、标识符

7、驼峰命名法

包、变量、方法、常量等

8、变量

9、常量

10、数据类型

基本数据类型

byte、short、int、long

float、double

char

boolean

类型转化：

自动类型转化

强制类型转化

11、运算符

算术运算符：+ - * /

++ –

以上是关于day04 基本数据类型与基本运算符的主要内容，如果未能解决你的问题，请参考以下文章

数据类型+与用户交互+格式化输出+基本运算符day03

day04_运算符

java基础语法学习day03---初学者必看详解

Python开发全栈-DAY-IV：Python基本数据类型

Day02-进制与基本数据类型介绍

python_day2基本数据类型

day04 基本数据类型与基本运算符

【四】基本数据类型

【1】数字类型

（1）整形（int）

(1.1)作用

(1.2)定义

（2）浮点型（float）

(2.1)作用

(2.2)定义

（3）数字类型的应用

(3.1)数字运算

(3.2)比较大小

【2】字符串（str）

（1）作用

（2）定义方式

（3）使用

【3】列表（list）

（1）作用

（2）定义

（3）使用

【4】字典（dict）

（1）作用

（2）定义

【5】布尔（bool）

（1）作用

（2）定义

（3）使用

【6】元祖（tuple）

（1）作用

（2）定义

【7】集合（set）

（1）作用

（2）定义

【五】程序与用户交互

【1】程序与用户交互

（1）什么是与用户交互

（2）为什么要与用户交互

（3）如何与用户交互

(3.1)输入（input）

(3.2)输出（print）

(3.3)输出之格式化输出

【六】基本运算符

【1】算数运算符

【2】比较运算符

【3】赋值运算符

（1）增量运算符

（2）链式赋值

（3）交叉赋值

（4）解压赋值

（5）逻辑运算符

(5.1)连续多个 and

(5.2)连续多个 or

(5.3)优先级 not>and>or

（6）成员运算符

（7）身份运算符

java基础语法学习day03---初学者必看详解

java基础语法学习day03---初学者必看详解

一、数据类型

1、基本数据类型

2、数据类型转化

2.1、基本数据类型的注意事项

2.2、 数据类型的转换

二、运算符

1、算术运算符

2、赋值运算符

3、关系运算符

4、连接运算符

5、逻辑运算符

6、三元/目运算符

(5.1)连续多个 `and`

(5.2)连续多个 `or`

(5.3)优先级 `not>and>or`

2.2、数据类型的转换