打基础~

珍妮王小钰

python 变量：
1.python不用事先声明变量，赋值过程中就包含了变量声明和定义过程。
2. 用‘=’赋值，左边是变量名，右边是变量的值。


List []有序的可变（可以修改）集合的容器。
左开右闭：
【0】第一个
【2：5】
【2：】三个开始

元组（）
不可变的列表。

字典{}
key- value的集合，无序的容器

print dict_a.keys()
print dict_a.values()

print dict_a.items()


运算符：
+=
-=
*=
/=
%=
**=
//=
----------------------------------------------------------
python  语句：
if
elif a==2:
print "a==2"
else:
print "a !=1 and a!=2"

for 用来遍历容器，或者执行重复性的代码。
遍历容器

list_a= [1,2,"test'"]
for i in list_a:
   print i
运行结果
1
2
test

执行重复性代码
for i in range(0,10):
   print i
运行结果
0
1
2
....
9

while
a=1
while a!=10:
   print a
   a+=1


for a in range(1,10):
  print a

break 语句：
list_a= [1,2,"test'"]
for i in list_a:
   print i

   if i ==2:
     break
从2跳出循环。
#[0,10]
但不能跳出多个循环：
for i in range(0,10):
    print i
for i in range(0,10):
    for j in range(0,10)
        print i,j
        if j==5：
           break

continue 直接进行下一次循环。(break是直接跳出整个循环;continue会走下一个循环）

list_a= [1,2,"test'"]
for i in list_a:
   print i

   if i ==2:
      continue

   print"~~~~"

珍妮王小钰

数据结构：
List:
python 内置的一种数据结构；有序；可更改（添加，删除）
声明
game=['dota','dota','lol']
game
['dota','dota','lol']

获取列表长度：
1 len(game)
2 3
获取元素：
game[0]
'dota'
game[2]
'lol'

增删查改

增加元素
末尾追加
game.append('wow')
game[3]
'wow'
game
['dota','dota','lol','wow']

删除元素
删除末尾的元素
game.pop()  
不写就默认删除最后一个。
‘wow'
game
['dota','dota','lol']
改元素
game[0]='dota2'
game
['dota2','dota','lol']

tuple:
python 内置的一种数据结构；有序；不可更改（安全）；在赋值的时候决定所有元素


声明
game=（'dota','war3','lol'）
game
（'dota','war3','lol'）
声明完后不用更改，安全
获取列表长度：
len(game)
  3

获取元素：
game[0]
'dota'
game[2]
'lol'



dict:
python内置的一种数据结构；无序；可更改
类似于C++语言的map,存键值对，有很快的查找速度。比如根据身份证号查找某个热难道名字，根据学号查找学生成绩单。用List遍历也可以得到结果，但是太慢了，list就好像你在小区找人，一家家敲门。dict就好像你直接按照地址找。
dict用空间换时间，占内存大，但查找插入速度很快不会随着元素数量增加而增加。list是时间换空间的例子。不会占用大量内存，但随着元素数量增加，查找时间会变很长。
声明
name={1:'alan', 2:'bob', 3:'lucy'}
查找
name[1]
'alan'
name[2]
'bob'
为了避免出现报错情况我们一般要事先判断一下这个key是否在dict里面:
5 in name
false.
2 in name
true
也可以用get方法取，如果key不存在，会返回None或者自己定义的默认值。
name.get(5)
name.get(5,'default')
"default"没找到
增加
name[5]='sam"
name
{1:'alan', 2:'bob', 3:'lucy',5:'sam'}
删除
name.pop(1)
’alan'
name
{ 2:'bob', 3:'lucy'}
name.pop(5)
‘sam'
name
{1:'alan', 2:'bob', 3:'lucy'}
len（name)
3(三个键值对）
name.key()
[1,2,3]
name.values()
['alan', 'bob','lucy]
name.items()
[(1,'alan'),(2,"bob'），（3，“lucy')]

珍妮王小钰

set:
python内置数据结构；无序；可更改
set可以视为没有value的dict,只存key,一般用做去重或者集合求交，求并等。
声明
girls_1=set(['lucy','lily'])
girls_2=set(['lily','anna'])           
求并，交
girls_1&girls_2
set(["lily'])
girls_1|girls_2      
set(['lily','lucy','anna']
增加元素
girls_1.add('marry')
girls_1
set(['marry','lily','lucy'])
删除元素
girls_1.remove('lucy']
girls_1
set(['marry','lily'])

python 函数
函数是可重复调用的代码短，能提高代码的复用率。
定义格式
#无参数
def print_hello():
    print"hello"
print_hello()--hello
#带参数
def print_str(s)
print s
return s*2
print_str("fuck")
--fuckfuck

#带默认参数
def print_default(s='hello'):
   print s
print_default()
print_default("default")
-hello
-default
#不定长参数
def print_args(s,*arg):
  print s
  for a in arg:
     print a
return

print_args("hello")
print_args("hello","world","1")
*"world","1" 存放在arg里。
-hello
-hello
world
1

#参数次序可以变
def print_two(a,b):
   print a,b

print_two(a="a", b="b")
print_two(b="b",a ="a"
a b
a b

珍妮王小钰

https://www.zhihu.com/question/57449577 笨办法才是好方法。每个代码敲三遍，第一步抄；第二遍保留框架 注释自己默写，第三从头到尾白板一遍。 |把学到的整理成博客。
https://zhuanlan.zhihu.com/gaihangcs 改行CS
G: 基本功，综合能力（灵活）


eX: 一个笔记本电脑4g  1TB data， 怎么找到所有的数据？？给你一万台1g XXXdata（用mapreduce 找到data所有pair）算法+系统设计。 考problem solving的能力。two sum: 30~35 女生，口红裙子 找ID

---------------------------------
part 1 系统CS理论知识
part2 扎实的一线公司coding skills
part3 工业界项目-> Outstanding Resume
         New: 第四个月，三个工业界大项目
part4. 面试软实力
part5. Referral +职业发展 平台。

珍妮王小钰

简介

面向对象是我们经常能听到的术语，即class，类。事实上，主角是两个，一个是类，一个是类实例。人类，是一个类，我们每一个人是一个人类的实例。而类之间又有一些关系，例如，我们既是人类，也是动物，更细化来讲，我们是哺乳类动物，灵长类，类似于集合的概念，哺乳动物属于动物，而在面向对象中我们通常称哺乳动物是动物的子类。而对于动物这个类来说，会自带一些属性，例如：年龄、体重。也会有一些方法：生殖、呼吸。而不同种类的动物（即动物类的各种子类）可能会有不同的属性或方法，像胎生、卵生，像鸟类的飞行的方法和豹子奔跑的方法。

定义

用关键字class去定义一个类，如果没有指定父类，默认继承object类。

• class Human(object):
•     pass
  

这样，我们定义个了一个Human，人类。

类属性

• class Human(object):
•     taisheng = True
  

为什么要叫类属性呢，因为这个属性是和类绑定的，并不是和实例绑定的。胎生这个属性是全人类共有的，并不是某个人特殊拥有的属性。

实例属性

• class Human(object):
•     def __init__(self, name):# 构造函数。用来作为这个实例的初始化。
•         self.name = name
• human_a = Human("alan")
  

我们首先实例化了一个人类human_a，然后给这个人类设置了一个实例属性name，name这个属性独立于其他的人类，是和实例绑定的，所以叫实例属性。#实例属性是针对某个实例的。 例属性可以在实例创建后任意时间设置。

• 一般放在构造函数里__init()__
  

类方法

• class Human(object):
•     def __init__(self, name):
•         self.name = name
•     def walk(self):
•         print self.name + " is walking"
• human_a = Human("alan")
• human_a.walk()
  

运行结果：

• alan is walking
  

类的方法可以看做是一种类属性，而传入的第一个参数self，表示调用这个类方法的实例。像上面的例子，human_a调用了walk这个类方法，human_a的名字是alan，所以运行的结果就是alan is walking。

访问控制

从上面的例子来看，我们可以在外部随意更改name这个属性，如果不想让外部直接访问到，则在属性名字前加两个下划线__name，这样从外部就无法直接访问了。如果还是想访问，可以再加个get的接口。

• class Human(object):
•     def __init__(self, name):
•         self.__name = name
•     def walk(self):
•         print self.name + " is walking"
•   def get_name(self):
•         return self.__name
• human_a = Human("alan")
• print human_a.get_name()
• print human_a.__name
  

如果还是想更改__name字段，可以再加上一个set接口

• class Human(object):
•     def __init__(self, name):
•         self.__name = name
•     def walk(self):
•         print self.name + " is walking"   
•     def get_name(self):
•         return self.__name
• def set_name(self, name):
•         self.__name = name
• human_a = Human("alan")
• print human_a.set_name("bob")
  

可能有人会有疑问，为何要这么“画蛇添足”呢？其不然，这样会增强代码的健壮性，直接暴漏属性可能会带来意想不到的后果，通过接口的方式可以加以控制，例如，我们可以通过set接口去限定name的长度。

• class Human(object):
•     def __init__(self, name):
•         self.__name = name
•     def walk(self):
•         print self.name + " is walking"
•     def get_name(self):
•         return self.__name
•     def set_name(self, name):
•         if len(name) <= 10:
•             self.__name = name
• human_a = Human("alan")
• print human_a.set_name("bob")
  

这样就不会出现name过长的情况。

继承

最开始的简介里说到，哺乳动物是动物的一种，用面向对象的属于来说，哺乳动物是动物的子类，子类拥有父类的属性、方法，即继承。同时又可以拥有父类没有的属性和方法，即多态。
还是以人类为例，通常来说，人类又可以分为男人和女人（当然也有别的，23333）

• class Human(object):
•     def __init__(self, name):# 构造函数。用来作为这个实例的初始化。
•        self.name = name
• ------------------------------------
  

• class Man(Human):
•     def __init__(self, name, has_wife):
•         self.__name = name
•         self.__has_wife = has_wife
  

来，我们看下这个男人，多了一个新的属性，__has_wife(是否已婚)。我们写到了Man的构造函数里。其实通常并不这么写构造函数，假如Human里有很多属性、很多初始化步骤，我们Man继承的时候难不成要复制粘贴一遍Human的构造函数？当然不是啦，通常会这么写。

• class Man(Human):
•     def __init__(self, name, has_wife):
•         super(Man, self).__init__(name)
•         self.__has_wife = has_wife
  

super(Man, self).__init__(name)等价于调用了父类Human的构造函数，就不用再复制粘贴一遍了。
既然有男人，那就再来个女人吧。

• class Woman(Human):
•     def __init__(self, name, has_husband):
•         super(Woman, self).__init__(name)
•         self.__has_husband = has_husband
  

我们都道，男人和女人是不一样的，通常男人都自带抽烟、喝酒、烫头，啊。。。并没有烫头。

• class Man(Human):
•     def __init__(self, name, has_husband):
•         super(Man, self).__init__(name)
•         self.__has_husband = has_husband
•     def smoke(self):
•         print "A man maybe smoke"
•     def drink(self):
•         print "A man maybe drink"
  

当然，女人也自带逛街、化妆等天赋技能。

• class Woman(Human):
•     def __init__(self, name, has_husband):
•         super(Woman, self).__init__(name)
•         self.__has_husband = has_husband
•     def shopping(self):
•         print "A woman always go shopping"
•     def make_up(self):
•         print "A woman always make up"
  

好了，观众朋友们，有没有感觉到这种继承的优越性。可以很清晰地看到，男人和女人都有一些相同的属性，也有一些各自不同的方法。如果哪天人类有了别的方法、属性，直接在Human类更改，男人和女人也会自动继承。如果想再设计一个双性人这个类，那直接从Human继承就可以了，对男人和女人不会有任何影响。这就是面向对象的优越性啊！

珍妮王小钰

del del(x[1])

The ; sign is used to place commands on the same line.
# Same line
command1; command2


# Separate lines
command1
command2

although you've changed areas_copy, the change also takes effect in the areas list. That's because areas and areas_copy point to the same list.If you want to prevent changes in areas_copy from also taking effect in areas, you'll have to do a more explicit copy of the areas list. You can do this with list() or by using [:]# Create list areas
areas = [11.25, 18.0, 20.0, 10.75, 9.50]

# Create areas_copy
areas_copy = list(areas)

# Change areas_copy
areas_copy[0] = 5.0

# Print areas
print(areas)

珍妮王小钰

# string to experiment with: place
place = "poolhouse"

# Use upper() on place: place_up
place_up = place.upper()

# Print out place and place_up
print(place)
print(place_up)

# Print out the number of o's in place
print(place.count('o'))