03--Python基础

 基本数据类型

2/2 为浮点型 ，想变成整形的可以写为2//2 即可

1/2 为浮点型0.5 1//2 为整型0

0b为二进制的标示符 0o为八进制的标示符 0x为16进制的标示符

bin() 其它进制的数转化为二进制：

bin(10) 将十进制10转化为二进制
bin(0o7)将八进制7转化为二进制
bin(0xE)将十六进制14转化为二进制

int() 其它进制的数转化为十进制：

int(0b111) int(0o777)

oct() 其它进制的数转化为八进制：

oct(0b878) oct(0x727)

hex() 其它进制的数转化为十六进制：

hex(888) int(0o77777)

 

number 数字 bool布尔 complex复数

True 真的 False 假的 T和F都要大写，否则会出错

int(True) 值为1 int(False) 值为0

bool(1) 值为True bool(0) 值为False

综合上面两行转化结果，证明bool类型也是数字类型 True 代表1 False 代表0

注意：
bool(2) 值为True bool(2.2) 值为True bool(-1.1) 值为True bool(0) 值为Flse

综合本条：任何非0的布尔值都是True，0的布尔类型为Flase

 

注意2：
bool('abc') 值为True bool('') 值为Flase

bool([1,2,3]) 值为True bool([]) 值为Flase

bool({1,2,3}) 值为True bool({}) 值为Flase

综合本条：任何非空值的布尔值都是True，空值的布尔类型为Flase

注意3：
bool(None)的值为Flase

 

字符串：

"let's go" ; 'let" s go ' ; 'let\'s go ' (使用转义字符\)

英文下的 单引号 双引号 三引号；它们需要成对出现。

三引号:

>>>"""
hello word
hello word
hello word
"""

>>>'''
hello word
hello word
hello word
'''
使用三引号可以让字符串多行书写，3个单引号或3个单引号都是可以的。

>>>"""
hello word\nhello word\nhello word
"""
>>>'hello word\nhello word\nhello word'

三引号里面的\n不会被IDE识别为回车，IDE会认为这是字符串里面的内容，引号不一定要必须换行。

>>>print("""hello word\nhello word\nhello word""") （重点，print是引号就行）
>>>hello word
hello word
hello word

用print打印出三引号里面的内容，\n也会被IDE识别为回车，可以出现回车效果。

扩展：
>>>‘hello\
word’
也是可以换行操作不会报错的。

 

转义字符：
转义字符是特殊的字符，无法看见的字符，回车，空格等等；或者是和语言本身语法有冲突 的字符。

\n 换行 \r回车 \' 单引号 \t 横向制表符

>>>print("hello \n word")

hello
word

将\n解析为换行符

>>>print("hello \\n word")
hello \n word

将\\n解析为字符串\n


\应用场景：
解决方案一：>>>print("c:\\north\\thwes")

解决方案二：>>>print(r"c:\north\thwes") （r不区分大小写）

加上r之后，就代表着r后面的字符串不是普通的字符串，而是一个原始的字符串，
r后面的东西就不会被IDE解析成其他的了，而是原样执行。

 

字符串的运算：

>>> "hello"+"word"
'helloword'

>>> "hello"*3
'hellohellohello'

 

截取字符串字母：

>>>"hello word"[0]
'h'

>>>"hello word"[3]
'l'

>>>"hello word"[4]
'0'

>>>"hello word"[-1]
'd'

>>>"hello word"[-3]
'r'
字符串从正数代表字符串的序号，起始从0开始；负数代表从负数最末尾开始向后数几位。
字符串里的空格也代表一位。

截取字符串的一组（步长）：

>>>"hello world"[0：5]
'hello'

截取的是一组字符串，起始位置是0，结束位置是4（不包含5，是5的前一个）

>>>"hello world"[0：-1]
'hello worl'

截取的是一组字符串，起始位置是0，结束位置是-2（不包含-1，是-1的下一个）

>>>"hello world"[0：-3]
'hello wo'

截取的是一组字符串，起始位置是0，结束位置是-4（不包含-3，是-3的下一个）

>>>"hello world"[6：]"
'hello wo'

截取的是一组字符串，起始位置是6，结束位置是字符串的末尾（结束位置不写就代表着一直到字符串的结尾了）

 

 

 

 

 

 组概念

组的表示方法并不是只有一种。

列表表示：[]

>>> type([1,2,3,4])
<class 'list'>

>>> type(["hello",'word',2,3,4,True,False])
<class 'list'>

>>> type([[1,2],[3,4],[5,6],[False,True]])
<class 'list'>

列表套列表（嵌套列表 (/二维数组)）

一组游戏技能释放：

>>> ["新月打击","苍白之瀑","月之降临","月神冲刺"][0]
'新月打击'

>>> ["新月打击","苍白之瀑","月之降临","月神冲刺"][3]
'月神冲刺'

 

>>> ["新月打击","苍白之瀑","月之降临","月神冲刺"][0:2]
['新月打击', '苍白之瀑']

>>> ["新月打击","苍白之瀑","月之降临","月神冲刺"][-1:]
['月神冲刺']

用单个序号释放的技能，得到的是字符串；用加：的步长得到的是列表组。

追加一组技能：
>>> ["新月打击","苍白之瀑","月之降临","月神冲刺"]+["虚弱","点燃"]
['新月打击', '苍白之瀑', '月之降临', '月神冲刺', '虚弱', '点燃']

使用 + 号在之前列表后面追加一组技能。

重复技能：
>>> ["虚弱","点燃"]*3
['虚弱', '点燃', '虚弱', '点燃', '虚弱', '点燃']

使用 * 号使技能重复3次。

注意：没有减号和除号操作。

 

元组表示：（）

>>> (1,2,3,4,5)
(1, 2, 3, 4, 5)

>>> (1,'-1',True)
(1, '-1', True)

>>> (1,2,3,4)[0]
1

>>> (1,2,3,4)[0:2]
(1, 2)

>>> (1,2,3,4)+(5,6)
(1, 2, 3, 4, 5, 6)

>>> (1,2,3)*3
(1, 2, 3, 1, 2, 3, 1, 2, 3)

元组的奇怪现象：

>>> type((1,2))
<class 'tuple'>

>>> type((1))
<class 'int'>

因为只输入一个数字（1），IDE会认为是运算符的小括号，所以会解析为整形1，

这样就和元组冲突了。如果要表示一个数值的元组时要在后面加个逗号（1，），

如果要表示一个空元组的话，可以写成（（）），里面什么都不添加内容。

序号：

str list tuple 他们都有序号，都可以用中号号里面的序列来提起内容。

切片：

和步长的意思一样 [0:3]

查找数值是否在列表/元组：

>>> 3 in [1,2,3,4,5,6]
True

3是不是在元组里，是，返回True

>>> 3 not in [1,2,3,4,5,6]
True

3是不是不在元组里，不是，返回False

>>> len([1,2,3,4,5,6])
6

测试元组的长度

>>> max([1,2,3,4,5,6])
6

测试元组的最大值

>>> min([1,2,3,4,5,6])
1

测试元组的最小值

字符串类型的同样，大小是按照英文字母表排序的。

将字母转化为阿斯克码：

>>> ord("w")
119

>>> ord("d")
100

字符串的大小其实是阿斯克码对应的大小。

 

集合 set:

特点：无序 不重复 用{}表示，无法使用下标索引，无法使用切片操作。(集合有减法)

>>>{1,2,3,4,5,6}-{3,4}
{1,2,5,6} 差集

>>>{1,2,3,4,5,6}&{3,4}
{3,4} 交集

>>>{1,2,3,4,5,6}|{3,4，7}
{1,2,3,4,5,6,7} 并集

set() 定义一个空的集合
>>>type(set())
0

字典 dict:

格式：{key1:value1,key2:value2....}

>>> type({1:1,2:2,3:3})
<class'dict'>

游戏技能快捷键：

>>>{'Q':'新月打击'，'W':'苍白质朴'，'E':'月之降临'，'R':'月神冲刺'}['Q']
'新月打击'

key不允许重复，不能使用[1],key可以是数字或字符串等，key必须是不可变的类型。

value可以是：str int float list set dict

空的字典定义：{}

 

 

 

 

 

 

变量与运算符

变量

>>>A = [1,2,3,4,5,6]

>>>B = [1,2,3]

>>>A*3 + B + A

>>>[1,2,3,4,5,6,1,2,3,4,5,6,1,2,3,4,5,6,1,2,3,1,2,3,4,5,6]

变量名要取得有意义

变量名可以是 字母 数字 下划线 区分大小写 ；

变量名不可以是系统关键字，保留关键字。

 

 

值类型和引用类型的区别：

>>>a = 1

>>>b = a

>>>a = 3

>>>print(b)
1
值类型

>>>a = [1,2,3]

>>>b = a

>>>a[0] = '1'

>>>print(b)

['1',2,3]
引用类型

总结：值类型和引用类型出现完全不同的结果，是因为值类型是不可变的，在a=3的时候

a开辟了一块新内存，但原来的数值还在，所以b还是指向1；

引用类型是可变的，在把‘1’复制给列表的第一个元素时，不会再开辟另一块新

的内存，会在原来的基础上修改。

id() 检测字符在内存里的地址

重点 归纳：综上所述，

值类型： int str tuple (不可改变)

引用类型：list set dict (可变)

 

引用类型可用append 向其后面追加元素，例如：

>>>b = [1,2,3]

>>>b.append(4)

>>>print(b)

[1,2,3,4]

二维数组： (访问 b)

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

>>>a[3][2][1]
b

一层一层访问，先访问外面的那一层

 

 

逻辑运算符特殊知识：

>>> 1 and 2
2

and逻辑运算符同真为真，系统需要找到两个值后才能进行对比，系统和人一样，为 了节省计算，会返回最后的那一个。

>>> 1 or 2
1

or逻辑运算符有一个真为真，系统只需要找到第一个值是不是真的，如果是真的，系统就不会接着看后面的了，为了节省计算，会返回第一个真的值，如果是假的，则继续判断后面的。

 

逻辑运算符键值对知识：

>>> b = 'a'

>>>a in {'c':1}
False

 

>>> b = 1

>>>b in {'c':1}
False

 

>>> b = 'c'

>>>b in {'c':1}
True

总结：它判断的是Key的值，和Value没有关系。

 

is(是) is not（不是）：

>>> a = 1

>>> b = 2

>>> a is b
False

 

>>> a = 1

>>> b = 1

>>> a is b
True

 

>>> a = 1

>>> b = 1.0

>>> a is b
False

总结：is 不是比较值相等，is 比较的是两个变量的身份是否相等。看内存地址是否相等。

 

>>> a = {1,2,3}
>>> b = {2,1,3}
>>> a == b
True

集合是无序的，所以只要内容一样即为真。

 

>>> a = （1,2,3）
>>> b = （2,1,3）
>>> a == b
False

元组是有序的，内容位置不一样的话即为假。

 

isinstance用法：

isinstance（a,str） 判断a是不是字符串类型

isinstance（a,（str，int,float）） 判断a是不是字符串类型 ,整型，浮点型其中的一 种。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 分支、循环、条件与枚举

 

if else :

用if else编写程序，判断用户登录名是否正确，并给出提示：

ACCOUNT = 'chenyongteng'
PASSWORD = 'teng12345'

print('请输入您的账号')
user_account = input()

print('请输入您的密码')
user_password = input()

if ACCOUNT == user_account and PASSWORD == user_password:
print("恭喜您，登录成功")

else:print("登录失败，请确认您的账号和密码")

程序总结：python 没有常量的概念，建议不变的量全部用大写字母表示。

建议每个模块要有一段描述性的文字。

建议不要在if后面的那个冒号前面加空格。

建议要在==左右两边各空一格。

 

while循环：

teng = 1

while teng <= 10:
teng += 1
print(teng)
else:
print('我循环完毕了')

 

for循环：

基础：

a = [1,2,3,4]

for x in a:
print(x)

遍历列表

 

 

a = [1,2,3,4]

for x in a:
print(x)

else:
print('我循环完毕了')

遍历完列表后，打出一句话。

 

a = [1,2,3,4]

for x in a:
if == 2:
break
print(x)

else:
print('我循环完毕了')

遍历列表，遇到2后停止循环跳出，不再循环；换成continue,跳出本次循环，
后面的继续循环。

 

for循环二维数组:

进阶：

a = [['apple','orange','banana'],(1,2,3)]

for x in a:
for y in x:
print(y)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

包 模块 类

 

python 的组织结构： 包 模块 类

包：包就相当于一个文件夹，模块相当于文件下面的.py文件，但是需要创建 一个__init__名称的文件，来告诉python,这是一个包。

 

引用包：import name , import驾驶模块名即可引用。

举例：引入方法1：import t.c7 （t文件夹下的C7文件。） 导入的是一个模块

举例：引入方法2：from t.c7 import a （引入t文件夹下的C7文件的a变量。） 导入的是一个模块里面的具体变量