python

python笔记2

位运算（二进制）
1.计算机中最小的单位：位
2.字节：1个字节  = 8个位
           （1byte = 8bit）
3.0000 0000-----1111 1111(255)
能存256个数
4. 八位最前面的为符号位：
 0表示正，1表示负
-10:1000 1010      能存储到 -127  +127  0  +0   1000 0000代表-128
10:0000 1010        共256个数
5. -3:1000 0011
+2:0000 0010
-------------
      1000 0101：代表-5      计算错误
6. 原码、反码、补码------解决负数的计算错误
（1）原码：数值的标准的二进制位
（2）反码：在原码的基础上符号位不变，其他位取反
（3）补码：反码+1
（4）正数的原码、反码、补码一致

-3的原码：1000 0011
-3的反码：1111 1100
-3的补码：1111 1101

-3+2
      1111 1101
   +  0000 0010
-------------------
      1111 1111(补码）
             1111 1110（反码）
             1000 0001（原码）
             故结果为-1

正数没有原码、反码、补码
计算机底层基于补码进行运算

7. &：两真才为真，一假则为假
5&6
0000 0101
0000 0110
----------
0000 0100  （4）
8. |：一真则真，两假才假
5|6
0000 0101
0000 0110
-----------
0000 0111  （7）
9. ^（异或）：相反为真，相同为假
10^11
0000 1010
0000 1011
----------
0000 0001

num^0=num
10. ~(按位取反）:包含符号位一起取反
~2
 2：0000 0010（原码）
~2：1111  1101（补码）
    1111 1100（反码）
        1000 0011 （原码）-----    -3
     
11. >>:右移
8>>2                   0000 1000
 (8右移2位）      00 001000
----------------------------
              0000 0010     （2）
 右移：除以2的n(右移几位）次方
12. <<:左移
8<<2                    0000 1000
                        0000 1000
--------------------------
              0010 0000      （32）
左移：乘以2的n（左移的位数）次方
13. 补码相加，最高位前进1，直接去掉
              1 0000 0001
                    （则去掉前面的1）
三元运算符：
条件成立时执行的代码   if 表达式 else 表达式
【print("111") if 2 >3 else print("333") 】
程序结构：
      顺序结构
      选择结构
      循环结构
选择结构：
1.关键字：if
   （1）if表达式：
                            代码块
       if表达式
a = input("请输入用户名：")
b = input("请输入密码：")
if a == "karry" and b == "0921":
    print("恭喜你登陆成功！")

  易错点：
           1.==
      2. 表达式后的：不能省略
（2）if-else语句

      if     表达式：
                      代码块1
      else:
         【后不需要代码】

  a = input("请输入用户名：")
b = input("请输入密码：")
if a == "karry" and b == "0921":
    print("恭喜你登陆成功！")
else:
    print("用户名或者密码错误")
（3）if-elif-else

（4）if语句嵌套
python没有switch语句
 
2.字符串切片
索引：正数索引从0开始
           负数索引从-1开始
sname[start:end:step]
sname:要操作的对象名
start:切片开始的位置，包含自身，若省略不写，那么从0开始
end:切片结束的位置，不包含自身，如果省略不写，默认为字符串长度
step:步长，默认为1，步长省略，第二个冒号可以省略，第一个冒号不可省略
【切片包含左边不包括右边】

反转字符串-----s[::-1]
切除整个字符串----s[:]
a = input("请输出一句话")
if a[:] == a[: : -1]:
    print("此为回文")
else:
    print("此不是回文")
复杂数据类型
1.列表（list）
2.元组
3.集合
4.字典


（1）列表
         [元素1,元素2,……]----元素的数据类型可以是不相同的，列表之间可以进行嵌套
a = ["karry",9,21,[7,23,3,14]]
print(type(a))
#列表下标
print(a[0])
print(a[-1])
print(a[-1][2])
#len()    列表的长度
print(len(a))
#更新列表里的数据
a[1] = "嵩嵩"
print(a)
#列表里的加法和乘法
a = [921,723]
b = [314,115]
c = a+b
print(c)
#乘法
print(a*2)

#append----向列表的最末尾添加元素
karry = [9,21]
karry.append("嵩嵩")
print(karry)

#copy-----创建一个对象的副本
tf = karry.copy()
print("karry",karry)


#count-----统计元素在列表里出现的次数
print(karry.count(9))

#exend-----
p = [7,9,0,6]
list.extend(p)

#index
print(karry.index("嵩嵩"))


#insert(插入的位置的索引下标，插入的数据）
karry.insert(1,806)
print(karry)


#pop----删除末尾元素
l = karry.pop()
print(l)
#remove----用元素移除元素
#reverse----反转列表元素

#sort  排序
list1 = [7,90,89,543]
list1.sort(reverse=Ture)#---加了（reverse=Ture）为降序
print(list1)
#reverse----反转列表元素
list.karry()
print(list)
#pop(i),可以删除指定位置的元素，其中i为索引下标
列表切片：
a = [1,2,3,4,5,6,7]
print(a[0:3])

列表的特点：
不同类型元素、有序存储、允许元素重复、可以修改

（2）元组【元组的元素无法更改，元组里面的类型可以不同】-------tuple
          （元素1，元素2，元素3，……）
t = ("karry",9,21,[7,23,3,14])
print(type(t))
print(t[0])
print(t[0:3:1])

t1 = (1,2,3)
t2 = (5,6,7)
print(t1+t2)

#元组里面的元素不能改变，但是元组里的列表元素能够改变
t[-1][2] ="songsong"
print(t)

元组、列表、字符串的公共方法
#元组、列表、字符串的公共方法
'''
len()
max()
min()'''
list = [2,4,5,6,8.69]
tuple = (2,4,6,798,90)
str = "karry09210723"

print(max(list))
print(min(list))

print(max(tuple))
print(min(tuple))

print(max(str))
print(min(str))
元组的注意事项：
1.t =  1,2,3   ------（）不加时也为元组
2.t = (3)----为整型
     t = (3,)----_为元组【元祖中只有一个元素时，这个元素后面必须带  ， 否则不是元组 】
3.元组乘法：
y=(67,)
y*20
【则会把67乘以20份】

（3）集合    {}----集合是无序的，且集合的元素是唯一的【可以用来去重】
1.集合的创建
               set()
#set()
#传入字符串-----把其用''引起来再分割开来   用，隔开
a = set("1234")
print(a)
#传入列表
b = set([1,2,9,'karry'])
print (b)
#传入元组
c = set ((10,20,30))
print(c)
#传入字典-------只会取键
d ={
    "年龄":"18",
    "姓名":"karry"
}
e = set(d)
print(e)

#{} 这里只能放 元组、字符串、数字,不能放列表和字典
#f={[1,2,3]}
#print(f)

f ={(1,2,3),"karry"}
print(f)
2.去重【{}不会去重，只会当做整体输出】
#列表去重
list = [1,2,3,4,5,6,2,3,4,5,2,1,3,4]
s = set(list)
print(s)
#元组去重
tuple = (2,4,6,3,2,1,3,4,5,6,7,4,53)
se = set(tuple)
print(se)
#字典去重---只针对键
a = {
    "name":"karrt",
    "name":"huhu"
}
yy = set(a)
print(yy)
#字符串的去重
hh = "yuanminghao"
mm = set(hh)
print(mm)


3.集合方法
#pop()----删除
s1.pop()
print(s1)

#discard()------里面放要删除的元素      不存在的话，不会做任何操作
s1.discard("a")
print(s1)
s1.discard(3)
print(s1)

#交集和并集
#&----交    连接多个集合，得到集合之间相同的元素
s3 = {1,2,3,4}
s4 ={3,4,5,6}
s6 ={4,5,6,7,8}
s5 = s3&s4&s6
print(s5)
#|---并     连接多个集合，得到所有的全部数据
s7 = s3 | s4 |s6
print(s7)


（4）字典
    键值对“uname”:"zs"      不重复
    键可以是任意的不可变类型----数字、字符串、元组

1.字典的创建
2.#{}
dict_01 ={
    "uname":"karry",
    "age":"24",
    9:"21",
    (1,2,3):"songsong"
}
print(type(dict_01))
# dict()函数
dict_02 = dict((["uname","karry"],[9,21]))
print(type(dict_02))

#创建空字典              {}默认创建的是空字典
dict_03 = {}
print(type(dict_03))


dict_04 =dict()
print(type(dict_04))
#创建空集合
set_02 = set()
print(type(set_02))

2.字典的方法
dict_01 ={
    "姓名":"karry",
    "年龄":"24"
}
#增
dict_01["技能"]="ACE"
print(dict_01)
#删
del dict_01["年龄"]
print(dict_01)
#改
dict_01["技能"]="全能ACE"
print(dict_01)
#查
print(dict_01["技能"])
3.get keys函数
4.#get()-----【在字典中获取指定键的值】可以设置默认值，当查询键不存在时返回默认值
d ={
    "姓名":"karry",
    "年龄":24
}
r = d.get("姓名")
print(r)
r1 = d.get("技能","ACE")
print(r1)

#keys()  以列表的形式返回字典中所有的键      字典嵌套字典，不会返回内部字典的键
s = d.keys()
print(s)

k = {
    "age":24,
    "技能":{
        "技能1":"青年演员",
        "技能2":"ACE"

    }
}
s1 = k.keys()
print(s1)

#items()  以列表的形式返回字典中所有的键值对
s2 = k.items()
print(s2)

#values()    以列表的形式返回字典中所有的值
s3 = k.values()
print(s3)

#clear()   清空
#k.clear()
#print(k)

#copy()     创建字典副本

#fromkeys()      创建一个新的字典,
k1= k.fromkeys(("uname","age"),("karry","24"))
print(k1)

#popitem()    删除最后一项，同时会以元组的形式返回删除的键值对
aj = k.popitem()
print(aj)
print(k)


#setdefault()   设置默认值
k.setdefault("技能","ACE")
print(k)

# update()
#将字典2的值更新到字典1，重复，会进行修改
y = {
    "uname":"karry"
}
m ={
    "uname":"songsong",
    "age":24
}
y.update(m)
print(y)