Python初初初初初初学

1.字面量

字面量类型:
1.字符串
2.字节
3.数字

1.字符串

字符串是字符的容器,一个字符串可以存放任意数量的字符
字符串和元组一样无法修改

2.字节

字节是计量单位，表示数据量多少，是计算机信息技术用于计量存储容量的一种计量单位，通常情况下一字节等于八位
一般在英文状态下一个字母或字符占用一个字节，一个汉字用两个字节表示

3.数字

分为整数(int)和浮点数(float),浮点数可用%.nf控制浮点数精度(n表示小数保留位数)

a = ("%.2f" % 2.555)

表示将2.555四舍五入保留两位小数,结果为2.56

---

2.注释

确保对模块, 函数, 方法和行内注释使用正确的风格
Python 中的注释有单行注释和多行注释
Python 中单行注释以 # 开头,一般# 后面打一个空格再写注释内容

# 单行注释

多行注释用三个单引号 ‘’’ 或者三个双引号 “”" 将注释括起来

"""多行
   注释
"""

---

3.变量

变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符

Python 中的变量赋值不需要类型声明
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建
等号 = 用来给变量赋值
等号 = 运算符左边是一个变量名，等号 = 运算符右边是存储在变量中的值

name = 100

将100赋值给name

---

4.数据类型

Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Sets（集合）
Dictionary（字典）

• Number（数字）
  分为 int、float、bool、complex

内置的 type() 函数可以用来查询变量所指的对象类型

 a,b,c,d=5,6.7,true,2+3j
 print(type(a),type(b),type(c),type(d))
 
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

PS：
1、Python可以同时为多个变量赋值，如a, b = 1, 2
2、一个变量可以通过赋值指向不同类型的对象
3、数值的除法（/）总是返回一个浮点数（print（2/4）输出0.5），要获取整数使用(//)操作符
4、在混合计算时，Python会把整型转换成为浮点数
5、布尔型：Ture和False、1和0
6、del语句可删除定义的对象，如：del a,b

• String（字符串）
  Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠转义特殊字符

字符串的截取的语法格式如下：
变量[第一个下标:最后一个下标]
索引值以 0 为开始值，-1 为从末尾的开始位置

加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数

例子：

str='hello,world!'

print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第五个的字符
print(str[2:])             # 输出从第三个开始的后的所有字符
print(str * 2)             # 输出字符串两次
print(str + '你好')        # 连接字符串

print('------------------------------')

print('hello\nworld')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nworld')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

执行结果:

hello,world!                  
hello,world                  
h                  
llo
llo,world!
hello,world!hello,world!
hello,world!你好

------------------------------

hello
world
hello\nworld

PS：

1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
2、字符串可以用+运算符连接在一起，用*运算符重复。
3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
4、Python中的字符串不能改变。
5、Python 没有单独的字符类型，一个字符就是长度为1的字符串。

• List（列表）

列表可以完成大多数集合类的数据结构实现。
列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号[]之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：
变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号（+）是列表连接运算符，星号（*）是重复操作。

例子：

list=['hello',357,6.6,'world']
ttlist=[123,'new']

print(list)                # 输出完整列表
print(list[0])             # 输出列表第一个元素
print(list[1:3])           # 输出从第2个开始到第3个元素
print(list[2:])            # 输出从第三个开始的后的所有元素
print(ttlist * 2)          # 输出两次列表
print(str + ttlist)        # 连接列表

执行结果:
['hello', 357, 6.6, 'world']
hello
[357, 6.6]
[6.6, 'world']
[123, 'new', 123, 'new']
['hello', 357, 6.6, 'world', 123, 'new']

与Python字符串不一样的是，列表中的元素是可以改变的：

>>> new=[1,2,3,4,5,'hi']       
>>> new
[1, 2, 3, 4, 5, 'hi']
>>> new[1]='hehe'           #改变列表new中的第2个元素为hehe
>>> new
[1, 'hehe', 3, 4, 5, 'hi']
>>> new[2:4]=[8,10]         #改变列表new中的第3/4个元素为8,9
>>> new
[1, 'hehe', 8, 10, 5, 'hi'
>>> new[2:4]=[]            #删除列表new中的第3、4个元素
>>> new
[1, 'hehe', 5, 'hi']
>>> new[2:3]=[]

PS：
1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片.
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。

• Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。
元组写在小括号()里，元素之间用逗号隔开。
元组中的元素类型也可以不相同。
元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取。
其实，可以把字符串看作一种特殊的元组。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()     # 空元组
tup2 = (20,)  # 一个元素，需要在元素后添加逗号
string、list和tuple都属于sequence（序列）。

PS：
1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含0或1个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。

• Sets（集合）

集合（set）是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合
PS：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

例子：

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'IKUN'}
print(student)  # 输出集合，重复的元素被自动去掉

成员测试

if ('IKUN' in student):
    print('IKUN 在集合中')
else:
    print('IKUN 不在集合中')

set可以进行集合运算

a = set('abracadabra')
b = set('alacazam')

print(a)
print(b)
print(a - b)  # a和b的差集
print(b - a)  # b和a的差集
print(a | b)  # a和b的并集
print(a & b)  # a和b的交集
print(a ^ b)  # a和b中不同时存在的元素
输出结果：

{'Jim', 'Mary', 'Rose', 'Tom', 'Jack'}
Rose 在集合中
{'d', 'c', 'r', 'a', 'b'}
{'l', 'c', 'm', 'a', 'z'}
{'d', 'b', 'r'}
{'l', 'm', 'z'}
{'l', 'd', 'c', 'r', 'm', 'a', 'b', 'z'}
{'c', 'a'}
{'l', 'd', 'r', 'm', 'b', 'z'}

• Dictionary（字典）

列表是有序的对象结合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。

键必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。

例子:

dict = {}
dict['one'] = "1 - hello,world"
dict[2] = "2 - 嘿嘿"

tinydict = {'name': 'lucy', 'code': 100, 'class': '5年级6班'}

print(dict['one'])  # 输出键为 'one' 的值
print(dict[2])  # 输出键为 2 的值
print(tinydict)  # 输出完整的字典
print(tinydict.keys())  # 输出所有键
print(tinydict.values())  # 输出所有值
输出结果:

1 - hello,world
2 - 嘿嘿
{'name': 'lucy', 'code': 100, 'class': '5年级6班'}
dict_keys(['name', 'code', 'class'])
dict_values(['lucy', 100, '5年级6班'])
内置函数：

get根据key值去对应的value取不到值返回None，不报错

>>> dic = {'k1':'v1','k2':'v2'}
>>> v = dic.get('k1')
>>> print(v)
v1
clear 清空

>>> dic = {'k1':'v1','k2':'v2'}
>>> v = dic.clear()
>>> print(dic)
{}
>>> print(v)
None
copy 拷贝（浅拷贝）

>>> dic = {'k1':'v1','k2':'v2'}
>>> v = dic.copy()
>>> print(v)
{'k1':'v1','k2':'v2'}
pop 删除并获取对应的value值

>>> dic = {'k1':'v1','k2':'v2'}
>>> v = dic.pop('k1')
>>> print(dic)
{'k2':'v2'}
>>> print(v)
v1
popitem 随机删除键值对，并获取到删除的键值

>>> dic = {'k1':'v1','k2':'v2'}
>>> v = dic.popitem()
>>> print(dic)
{'k1':'v1'}
>>> print(v)
{'k2':'v2'}
setdefault 增加，如果key值存在则不操作

>>> dic = {'k1':'v1','k2':'v2'}
>>> dic.setdefault('k3','v3')
>>> print(dic)
{'k1':'v1','k2':'v2','k3':'v3'}
update 批量增加或修改

dic = {'k1':'v1','k2':'v2'}
dic.update({'k3':'v3','k4':'v4'})
print(dic)
{'k1':'v1','k2':'v2','k3':'v3','k4':'v4'}

PS：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。

---

5.标识符

Python标识符的命名规则

Python 标识符由 26 个英文字母大小写，0-9 ，_ 组成
Python 标识符不能以数字开头
Python 标识符严格区分大小写
Python 标识符不能包含空格、@、% 以及 $ 等特殊字符
不能以系统保留关键字作为标识符

---

6.运算符

1.算术运算符

以下假设变量： a=10，b=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
// 取整除 :返回商的整数部分（向下取整）

2.比较（关系）运算符

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

3.赋值运算符

= 简单的赋值运算符
+= 加法赋值运算符
-= 减法赋值运算符
*= 乘法赋值运算符
/= 除法赋值运算符
%= 取模赋值运算符
**= 幂赋值运算符
//= 取整除赋值运算符

4.逻辑运算符

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

---

7.字符串

1.创建字符串

用" "或’ '将内容包括

str1 = "hello world"
str2 = 'hello world'

2.字符串内容的替换

replace方法

str3 = str1.replace("l","8")

把str1中的 l 替换为了 8
PS.字符串内容的替换不是修改字符串,而是得到一个新字符串

3.分割字符串内容

Python中字符串分割的常用方法是直接调用字符串的str.split方法

str4 = "100,200,300,400"
str4.split(',')

意思是用 , 分割字符串中的元素

---

8.if语句

num = float(input("输入一个数字: "))
if num > 0:
   print("正数")
elif num == 0:
   print("零")
else:
   print("负数")

内嵌 if 语句

if num >= 0:
   if num == 0:
       print("零")
   else:
       print("正数")
else:
   print("负数")

---

9.while循环

count = 0
while (count < 9):
   print 'The count is:', count
   count = count + 1
 
print "Good bye!"

运行结果:
The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!

while 语句时还有另外两个重要的命令continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出break所在的整个循环，此外"判断条件"还可以是个不为0的常值，表示循环必定成立

# continue 和 break 用法
 
i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print i         # 输出双数2、4、6、8、10
 
i = 1
while 1:            # 循环条件为1必定成立
    print i         # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break

---

10.for循环

语法1:

#range(num)
#获取一个从0开始,到num结束的数字序列(不含num本身)
range(5)
#获得的数据为{0,1,2,3,4}

#语法2

#range(num1,num2)
#获得一个从num1开始,到num2结束的数字序列(不包含num2本身)
range(5, 10) # 区间左闭右开
 获得的数据为{5,6,7,8,9}

语法3

range(num1,num2,step)
#获得一个从num1开始,到num2结束的数字序列(不包含num2本身)
#数字之间的步长,以step为准(step默认为1)
range(5, 10, 2) # 取其中间隔的一部分
取得的数据为{5,7,9}

for q in range(10): # for后面加任意字母
   print("玫瑰花")
e = 0
for w in range(1, 100):
   if w % 2 == 0:
       e += 1
print(e)

1.for循环临时变量作用域

i = 0
for i in range(10):
    print(i)
print(i)

如果要在循环外访问range,就要在外面定义全局变量
可以通过global将局部变量定义为全局变量

2.外层循环

i = 0
for i in range(1, 5):
    print(f"今天是第{i}天")
    # 内层循环
    for j in range(1,5):
        print(f"第{j}朵花")
    print("好看")
print(f"第{i}天,成功")


 for a in range(1, 10):
     for b in range(1, 10):
         print(f"{a}*{b}={a*b}")

for a in range(1, 10):
    for b in range(1, a+1):
        print(f" { a } * { b } = {a * b}\t", end='')
        # 输入end=''就不会输出换行
    print()# 换行

---

11.函数

1.函数定义

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。可以用 return 语句指定应该返回的值，该返回值可以是任意类型。需要注意的是，return 语句在同一函数中可以出现多次，但只要有一个得到执行，就会直接结束函数的执行。
  return 语句将Python函数的结果，返回到调用的地方，并把程序的控制权一起返回，即在函数中，执行到return语句时，会退出程序 (try…finally语句除外)； Python 函数中，没有return语句时，默认 return一个 None 对象；多个return语句时，运行到第一个return语句即返回，不再执行其它代码。

def printme( str ):
   "打印传入的字符串到标准显示设备上"
   print str
   return

2.调用函数

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
如下实例调用了printme（）函数：

# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print str
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

---

12.数据容器

1.列表(list)

python的列表的特点：

• 1可以随时添加和删除元素
• 2.可以方便的取元素
• 3.列表元素可以是不同类型

python列表的操作：
添加append，插入insert，删除remove/pop，排序sort，倒序reverse，合并extend等

#定义列表
li=['twilight','pinkiepie','rainbow dash']
#appand()   对象：列表  参数一：元素   返回值：无
li.append('apple jack')
print("after append:%s"%li)


#插入insert() 
对象：列表   参数一：要插入的下标  参数二：要插入的元素
li.insert(1,'rarity')
print("after insert:%s"%li)
#remove()   对象：列表   参数一：元素     返回值：无
li.remove('twilight')
print("after remove:%s"%li)
#pop()  对象：列表   参数一：元素的下标   返回值：无
li.pop(1)
print("after pop:%s"%li)


#排序sort()
 对象：列表 参数三：倒序  返回值：无
li.sort()
print("after sort:%s"%li)
#合并两个列表extend() 对象：列表   参数一：另一个列表  返回值：无
li.extend(['twilight','rainbow dash'])
print("after extend:%s"%li)
#倒序reverse()--快速降序排序：li.sort(reverse=True)
li.reverse()
print("after reverse:%s"%li)


#计算元素的个数count()
print("rainbow dash个数:%s"%li.count('rainbow dash'))
print("li 元素个数:%s"%len(li))
#查看元素的下标index() 对象：列表   参数一：要查找的元素  参数二：开始  参数三：结束  返回值：下标
print("第二个rainbow dash在哪里？%s"%li.index('rainbow dash',2))
#遍历列表,sys.stdout.write为了不换行输出
import sys
for i in li:            #li.__iter__()是list的迭代器,放在这里效果一样
    sys.stdout.write(i+",")
print()


#清空
li.clear()
print("after clear:%s" %(li))
运行结果：
after append:['twilight', 'pinkiepie', 'rainbow dash', 'apple jack']
after insert:['twilight', 'rarity', 'pinkiepie', 'rainbow dash', 'apple jack']
after remove:['rarity', 'pinkiepie', 'rainbow dash', 'apple jack']
after pop:['rarity', 'rainbow dash', 'apple jack']
after sort:['apple jack', 'rainbow dash', 'rarity']
after extend:['apple jack', 'rainbow dash', 'rarity', 'twilight', 'rainbow dash']
after reverse:['rainbow dash', 'twilight', 'rarity', 'rainbow dash', 'apple jack']
rainbow dash个数:2
li 元素个数:5
第二个rainbow dash在哪里？3
rainbow dash,twilight,rarity,rainbow dash,apple jack,
after clear:[]

2.元组(tuple)

1.元素个数不会变
2.元组的元素不会变
3.元组的元素的元素会变
tup=(‘twilight’,‘pinkiepie’,‘rainbow dash’)

方法—参考列表：
count()，index()

3.字典(dict)

特点：
1.查找快
2.可增添删减
3.键只能是基本数据类型，值可以是任意类型，键的类型可以不同

字典的操作：单独取出键值，用键取值，用值取键，添加，删除，遍历

dic1={'ts':'twilight','pp':'pinkiepie'}
print(dic1)
#取值get()
 对象：dict     参数一：键   参数二：没有值时代替值   返回值：值
print("ts the fullname:%s"%dic1.get('ts'))
print("rd the fullname:%s"%dic1.get('rd','rainbow dash'))
#添加键值或输出值setdefault()   对象：dict     参数一：键   参数二：没有值时代替值
 返回值：键的值
print(dic1.setdefault('pp'))
print("pp the fullname:%s"%dic1['pp'])
print(dic1.setdefault('rd',"rainbow dash"))
print("rd the fullname:%s"%dic1['rd'])


#遍历字典
import sys
my_keys=[]
my_values=[]
for k in dic1:
    my_keys.append(k)
print(my_keys)
for k in dic1:
    my_values.append(dic1[k])
print(my_values)


#键值格式化显示
for k,v in dic1.items():
    print("%s--->%s"%(k,v))


#直接变成列表
print(list(dic1.keys()))
print(list(dic1.values()))
print(list(dic1.items()))
#dic1.pop('rr')      #pop删除时，如果原来已经没有的会报错，可以设置默认值
dic1.pop('pp')
print(dic1)


#合并两个字典
update()
dic2={'aj':'apple jack','fs':'fluttershy'}
dic1.update(dic2)
print(dic1)
dic1.update(rr='rarity',pp='pinkiepie')   #可以使用函数可变值来更新字典
print(dic1)
#fromkeys用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print("New Dictionary : %s" %  str(dict))
dict = dict.fromkeys(seq, 10)
print("New Dictionary : %s" %  str(dict))


##### 4.集合(set)
集合的特点：
1.一个容器，集合的元素不重复
2.是无序的
3.集合的操作：并集，交集，差集
4.集合判断：是否是子集，是否有交集

集合的操作：

```p
set1={"pp","rr","tw"}
set2={"rd","pp","tw"}
print(set1,set2)
#专门用来输出
def output(*arg):
    fm1="{0}是{1}和{2}的{3}"
    fm2="{0}{1}{2}的{3}"
    if arg[1]==True:
        print(fm2.format(arg[0],"是",arg[2],arg[3]))
    elif arg[1]==False:
        print(fm2.format(arg[0],"不是",arg[2],arg[3]))
    else:
        print(fm1.format(arg[0],arg[1],arg[2],arg[3]))